@designliquido/delegua 0.43.5 → 0.44.1

package/interpretador/depuracao/interpretador-com-depuracao.js

@@ -0,0 +1,226 @@
+"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 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;
+    }
+    /**
+     * 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 visitarDeclaracaoEnquanto(declaracao) {
+        return await comum.visitarDeclaracaoEnquanto(this, declaracao);
+    }
+    async avaliarArgumentosEscreva(argumentos) {
+        let formatoTexto = '';
+        for (const argumento of argumentos) {
+            const resultadoAvaliacao = await this.avaliar(argumento);
+            let valor = (resultadoAvaliacao === null || resultadoAvaliacao === void 0 ? void 0 : resultadoAvaliacao.hasOwnProperty('valor'))
+                ? resultadoAvaliacao.valor
+                : 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);
+    }
+    /**
+     * 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 ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
+     */
+    async executarBloco(declaracoes, ambiente) {
+        return await comum.executarBloco(this, declaracoes);
+    }
+    /**
+     * 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.
+     * Se não for, apenas executa a instrução corrente.
+     */
+    async adentrarEscopo() {
+        throw new Error('Método não implementado.');
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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

package/interpretador/depuracao/interpretador-com-depuracao.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpretador-com-depuracao.js","sourceRoot":"","sources":["../../../fontes/interpretador/depuracao/interpretador-com-depuracao.ts"],"names":[],"mappings":"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"}

package/interpretador/index.d.ts

@@ -1,4 +1,3 @@
 export * from './interpretador';
 export * from './interpretador-base';
-export * from './interpretador-com-depuracao';
 //# sourceMappingURL=index.d.ts.map

package/interpretador/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../fontes/interpretador/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../fontes/interpretador/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC"}

package/interpretador/index.js

@@ -16,5 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./interpretador"), exports);
 __exportStar(require("./interpretador-base"), exports);
-__exportStar(require("./interpretador-com-depuracao"), exports);
 //# sourceMappingURL=index.js.map

package/interpretador/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../fontes/interpretador/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAAgC;AAChC,uDAAqC;AACrC,gEAA8C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../fontes/interpretador/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAAgC;AAChC,uDAAqC"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@designliquido/delegua",
-    "version": "0.43.5",
+    "version": "0.44.1",
     "description": "Linguagem de programação simples e moderna usando português estruturado.",
     "main": "index.js",
     "types": "index.d.ts",