@designliquido/delegua/interpretador/depuracao/interpretador-com-depuracao.js

Linguagem de programação simples e moderna usando português estruturado.

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.InterpretadorComDepuracao = void 0;
const construtos_1 = require("../../construtos");
const interpretador_1 = require("../interpretador");
const comum = __importStar(require("./comum"));
/**
 * Implementação do Interpretador com suporte a depuração.
 * Herda o Interpretador padrão de Delégua e implementa métodos a mais, que são
 * usados pelo servidor de depuração.
 * Alguns métodos do Interpretador original, como `executarBloco` e `interpretar`,
 * são reimplementados aqui.
 *
 * A separação entre `Interpretador` e `InterpretadorComDepuracao` se faz
 * necessária por uma série de motivos.
 * O primeiro deles é o desempenho. A depuração torna o desempenho do
 * Interpretador com depuração inferior ao Interpretador original pelas
 * várias verificações de controle que precisam ser feitas para a
 * funcionalidade do suporte a depuração, como verificar pontos de parada,
 * estados da pilha de execução e variáveis.
 * O segundo deles é manter o Interpretador original tão simples quanto possível.
 * Uma implementação mais simples normalmente é mais robusta.
 * O terceiro deles é o uso de memória. O Interpretador original não possui
 * uma série de variáveis implementadas aqui, o que o torna mais econômico em
 * recursos de máquina.
 */
class InterpretadorComDepuracao extends interpretador_1.Interpretador {
    constructor(diretorioBase, funcaoDeRetorno, funcaoDeRetornoMesmaLinha) {
        super(diretorioBase, false, funcaoDeRetorno, funcaoDeRetornoMesmaLinha);
        this.pontosParada = [];
        this.pontoDeParadaAtivo = false;
        this.avisoPontoParadaAtivado = () => console.log('Aviso: Ponto de parada ativado.');
        this.escopoAtual = 0;
        this.executandoChamada = false;
        this.passos = 0;
    }
    obterVariavel(nome) {
        return comum.obterVariavel(this, nome);
    }
    /**
     * Quando um construto ou declaração possui id, significa que o interpretador
     * deve resolver a avaliação e guardar seu valor até o final do escopo.
     * Isso serve para quando a linguagem está em modo de depuração, e o contexto
     * da execução deixa de existir com um ponto de parada, por exemplo.
     * @param expressao A expressão a ser avaliada.
     * @returns O resultado da avaliação.
     */
    async avaliar(expressao) {
        return await comum.avaliar(this, expressao);
    }
    async visitarExpressaoDeChamada(expressao) {
        return await comum.visitarExpressaoDeChamada(this, super.visitarExpressaoDeChamada.bind(this), expressao);
    }
    async visitarExpressaoBinaria(expressao) {
        return await comum.visitarExpressaoBinaria(this, 
        // super.visitarExpressaoBinaria.bind(this),
        expressao);
    }
    async visitarDeclaracaoEnquanto(declaracao) {
        return await comum.visitarDeclaracaoEnquanto(this, declaracao);
    }
    async avaliarArgumentosEscreva(argumentos) {
        if (this.constructor !== InterpretadorComDepuracao) {
            return await super.avaliarArgumentosEscreva(argumentos);
        }
        let formatoTexto = '';
        for (const argumento of argumentos) {
            const resultadoAvaliacao = await this.avaliar(argumento);
            if (argumento instanceof construtos_1.Atribuir || argumento instanceof construtos_1.AtribuicaoPorIndice) {
                formatoTexto += `${argumento.paraTexto()} `;
                continue;
            }
            let valor = this.resolverValor(resultadoAvaliacao);
            formatoTexto += `${this.paraTexto(valor)} `;
        }
        return formatoTexto.trimEnd();
    }
    /**
     * Execução de uma escrita na saída configurada, que pode ser `console` (padrão) ou
     * alguma função para escrever numa página Web.
     * Se ponto de parada foi ativado durante a avaliação de argumentos, não escreve.
     * @param declaracao A declaração.
     * @returns Sempre nulo, por convenção de visita.
     */
    async visitarDeclaracaoEscreva(declaracao) {
        return await comum.visitarDeclaracaoEscreva(this, declaracao);
    }
    async visitarDeclaracaoPara(declaracao) {
        return await comum.visitarDeclaracaoPara(this, declaracao);
    }
    async visitarDeclaracaoFazer(declaracao) {
        return await comum.visitarDeclaracaoFazer(this, declaracao);
    }
    /**
     * Ao executar um retorno, manter o valor retornado no Interpretador para
     * uso por linhas que foram executadas com o comando `próximo` do depurador.
     * @param declaracao Uma declaracao Retorna
     * @returns O resultado da execução da visita.
     */
    async visitarExpressaoRetornar(declaracao) {
        return await comum.visitarExpressaoRetornar(this, super.visitarExpressaoRetornar.bind(this), declaracao);
    }
    /**
     * Se bloco de execução já foi instanciado antes (por exemplo, quando há um ponto de parada e a
     * execução do código é retomada pelo depurador), retoma a execução do bloco do ponto em que havia parado.
     * Se bloco de execução ainda não foi instanciado, empilha declarações na pilha de escopos de execução,
     * cria um novo ambiente e executa as declarações empilhadas.
     * Se depurador comandou uma instrução 'adentrar-escopo', execução do bloco não ocorre, mas
     * ponteiros de escopo e execução são atualizados.
     * @param declaracoes Um vetor de declaracoes a ser executado.
     * @param espacoMemoria O ambiente de execução quando houver, como parâmetros, argumentos, etc.
     */
    async executarBloco(declaracoes, espacoMemoria) {
        return await comum.executarBloco(this, declaracoes, espacoMemoria);
    }
    /**
     * No interpretador com depuração, este método é dividido em dois outros métodos privados:
     * - `this.executarUmPassoNoEscopo`, que executa apenas uma instrução e nada mais;
     * - `this.executarUltimoEscopoComandoContinuar`, que é a execução trivial de um escopo inteiro,
     *      ou com todas as instruções, ou até encontrar um ponto de parada.
     * @param manterAmbiente Se verdadeiro, junta elementos do último escopo com o escopo
     *                       imediatamente abaixo.
     * @param naoVerificarPrimeiraExecucao Booleano que pede ao Interpretador para não
     *                                     verificar o ponto de parada na primeira execução.
     *                                     Normalmente usado pelo Servidor de Depuração para continuar uma linha.
     * @returns O retorno da execução.
     */
    async executarUltimoEscopo(manterAmbiente = false, naoVerificarPrimeiraExecucao = false) {
        return await comum.executarUltimoEscopo(this, manterAmbiente, naoVerificarPrimeiraExecucao);
    }
    /**
     * Continua a interpretação, conforme comando do depurador.
     * Quando um ponto de parada é ativado, a pilha de execução do TypeScript é perdida.
     * Esse método cria uma nova pilha de execução do lado do JS, começando do último elemento executado do
     * primeiro escopo, subindo até o último elemento executado do último escopo.
     * Se entre escopos houver ponto de parada ativo, a execução é suspensa até o próximo comando
     * do desenvolvedor.
     * @see executarUltimoEscopo
     */
    async instrucaoContinuarInterpretacao(escopo = 1) {
        await comum.instrucaoContinuarInterpretacao(this, escopo);
    }
    /**
     * Empilha um escopo se for possível (comando "Step Into" do depurador).
     * Se a instrução corrente contém uma chamada de função, entra na função e pausa na primeira linha.
     * Se não houver chamada de função, comporta-se como "próximo" (comando de passo).
     *
     * Fluxo de execução:
     * 1. Define o comando como 'adentrarEscopo'
     * 2. Executa um passo (que pode ou não entrar em uma função)
     * 3. Se entrou em função, o escopo da função fica no topo da pilha pronto para executar
     * 4. Se não entrou, a instrução é executada normalmente
     * 5. Ativa ponto de parada para aguardar próximo comando do usuário
     */
    async adentrarEscopo() {
        // Define o comando para indicar modo "adentrar escopo"
        this.comando = 'adentrarEscopo';
        // Limpa ponto de parada para permitir execução
        this.pontoDeParadaAtivo = false;
        // Executa um passo (que pode entrar em uma função se houver chamada)
        await this.instrucaoPasso();
        // Após execução, pausa para aguardar próximo comando do usuário
        // (a menos que um ponto de parada já tenha sido ativado durante a execução)
        if (!this.pontoDeParadaAtivo) {
            this.pontoDeParadaAtivo = true;
            this.avisoPontoParadaAtivado();
        }
    }
    /**
     * Interpreta apenas uma instrução a partir do ponto de parada ativo, conforme comando do depurador.
     * Esse método cria uma nova pilha de execução do lado do JS, começando do último elemento executado do
     * primeiro escopo, subindo até o último elemento executado do último escopo.
     * @param escopo Indica o escopo a ser visitado. Usado para construir uma pilha de chamadas do lado JS.
     */
    async instrucaoPasso(escopo = 1) {
        return await comum.instrucaoPasso(this, escopo);
    }
    /**
     * Interpreta restante do bloco de execução em que o ponto de parada está, conforme comando do depurador.
     * Se houver outros pontos de parada no mesmo escopo à frente da instrução atual, todos são ignorados.
     * @param escopo Indica o escopo a ser visitado. Usado para construir uma pilha de chamadas do lado JS.
     */
    async instrucaoProximoESair() {
        comum.executarUltimoEscopoComandoContinuar(this, false, true);
    }
    /**
     * Override para corrigir a ordem de execução de try-catch-finally em modo de depuração.
     * Em modo normal, executarBloco() executa o bloco imediatamente.
     * Em modo de depuração, executarBloco() apenas empilha o bloco para execução posterior.
     * Isso causa um problema onde o bloco finalmente é empilhado antes do bloco tente ser executado.
     * @param declaracao A declaração tente-pegue-finalmente.
     * @returns O valor retornado pela execução.
     */
    async visitarDeclaracaoTente(declaracao) {
        return await comum.visitarDeclaracaoTente(this, declaracao);
    }
    /**
     * Prepara a pilha de escopos para uma situação de depuração.
     * Não há execução de código neste caso.
     * @param declaracoes Um vetor de declarações.
     */
    prepararParaDepuracao(declaracoes) {
        this.declaracoes = declaracoes;
        comum.abrirNovoBlocoEscopo(this, declaracoes);
    }
    /**
     * Reimplementando este método aqui porque a execução por depuração não requer
     * mostrar o resultado em momento algum, ou lidar com o retorno.
     * @param declaracao A declaracao a ser executada.
     * @param mostrarResultado Sempre falso.
     * @returns O resultado da execução.
     */
    async executar(declaracao, mostrarResultado = false) {
        return await declaracao.aceitar(this);
    }
    /**
     * Interpretação utilizada pelo depurador para avaliar valores de variáveis.
     * Diferentemente da interpretação tradicional, não possui indicadores
     * de performance porque eles não fazem sentido aqui.
     * @param declaracoes Um vetor de declarações.
     * @returns Um objeto de retorno, com erros encontrados se houverem.
     */
    async interpretar(declaracoes, manterAmbiente = false) {
        this.erros = [];
        this.declaracoes = declaracoes;
        comum.abrirNovoBlocoEscopo(this, declaracoes);
        const resultado = await super.executarUltimoEscopo(manterAmbiente);
        // Corrigir contador de escopos
        this.escopoAtual--;
        const retorno = {
            erros: this.erros,
            // resultado: this.resultadoInterpretador // Removido para simplificar `this.executar()`.
            resultado: [resultado],
        };
        this.resultadoInterpretador = [];
        return retorno;
    }
}
exports.InterpretadorComDepuracao = InterpretadorComDepuracao;
//# sourceMappingURL=interpretador-com-depuracao.js.map