@designliquido/delegua 0.24.1 → 0.24.3

package/fontes/interpretador/dialetos/birl/interpretador-birl-com-depuracao.js

@@ -0,0 +1,68 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterpretadorBirlComDepuracao = void 0;
+const interpretador_com_depuracao_1 = require("../../interpretador-com-depuracao");
+const comum = __importStar(require("./comum"));
+class InterpretadorBirlComDepuracao extends interpretador_com_depuracao_1.InterpretadorComDepuracao {
+    constructor(diretorioBase, funcaoDeRetorno = null, funcaoDeRetornoMesmaLinha = null) {
+        super(diretorioBase, funcaoDeRetorno, funcaoDeRetornoMesmaLinha);
+    }
+    async atribuirVariavel(interpretador, expressao, valor, tipo) {
+        return comum.atribuirVariavel(interpretador, expressao, valor, tipo);
+    }
+    async resolveQuantidadeDeInterpolacoes(expressao) {
+        return comum.resolveQuantidadeDeInterpolacoes(expressao);
+    }
+    async verificaTipoDaInterpolação(dados) {
+        return comum.verificaTipoDaInterpolação(dados);
+    }
+    async substituirValor(stringOriginal, novoValor, simboloTipo) {
+        return comum.substituirValor(stringOriginal, novoValor, simboloTipo);
+    }
+    /**
+     * Execução da leitura de valores da entrada configurada no
+     * início da aplicação.
+     * @param expressao Expressão do tipo Leia
+     * @returns Promise com o resultado da leitura.
+     */
+    async visitarExpressaoLeia(expressao) {
+        await comum.visitarExpressaoLeia(this, expressao);
+    }
+    async visitarExpressaoLiteral(expressao) {
+        return comum.visitarExpressaoLiteral(expressao);
+    }
+    async visitarDeclaracaoPara(declaracao) {
+        return comum.visitarDeclaracaoPara(this, declaracao);
+    }
+    async avaliarArgumentosEscreva(argumentos) {
+        return comum.avaliarArgumentosEscreva(this, argumentos);
+    }
+    async interpretar(declaracoes, manterAmbiente) {
+        return comum.interpretar(this, declaracoes, manterAmbiente);
+    }
+}
+exports.InterpretadorBirlComDepuracao = InterpretadorBirlComDepuracao;
+//# sourceMappingURL=interpretador-birl-com-depuracao.js.map

package/fontes/interpretador/dialetos/birl/interpretador-birl-com-depuracao.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpretador-birl-com-depuracao.js","sourceRoot":"","sources":["../../../../../fontes/interpretador/dialetos/birl/interpretador-birl-com-depuracao.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,mFAA8E;AAC9E,+CAAiC;AAEjC,MAAa,6BAA8B,SAAQ,uDAAyB;IACxE,YAAY,aAAqB,EAAE,kBAA4B,IAAI,EAAE,4BAAsC,IAAI;QAC3G,KAAK,CAAC,aAAa,EAAE,eAAe,EAAE,yBAAyB,CAAC,CAAC;IACrE,CAAC;IAED,KAAK,CAAC,gBAAgB,CAClB,aAAyC,EACzC,SAAoB,EACpB,KAAU,EACV,IAAY;QAEZ,OAAO,KAAK,CAAC,gBAAgB,CAAC,aAAa,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACzE,CAAC;IAED,KAAK,CAAC,gCAAgC,CAAC,SAAkB;QACrD,OAAO,KAAK,CAAC,gCAAgC,CAAC,SAAS,CAAC,CAAC;IAC7D,CAAC;IACD,KAAK,CAAC,0BAA0B,CAAC,KAAmC;QAChE,OAAO,KAAK,CAAC,0BAA0B,CAAC,KAAK,CAAC,CAAC;IACnD,CAAC;IACD,KAAK,CAAC,eAAe,CAAC,cAAsB,EAAE,SAAc,EAAE,WAAmB;QAC7E,OAAO,KAAK,CAAC,eAAe,CAAC,cAAc,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;IACzE,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,oBAAoB,CAAC,SAAe;QACtC,MAAM,KAAK,CAAC,oBAAoB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IACtD,CAAC;IAED,KAAK,CAAC,uBAAuB,CAAC,SAAkB;QAC5C,OAAO,KAAK,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC;IACpD,CAAC;IAED,KAAK,CAAC,qBAAqB,CAAC,UAAgB;QACxC,OAAO,KAAK,CAAC,qBAAqB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACzD,CAAC;IAED,KAAK,CAAC,wBAAwB,CAAC,UAAuB;QAClD,OAAO,KAAK,CAAC,wBAAwB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAC5D,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,WAAyB,EAAE,cAAwB;QACjE,OAAO,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;IAChE,CAAC;CACJ;AAjDD,sEAiDC"}

package/fontes/interpretador/dialetos/birl/interpretador-birl.d.ts

@@ -1,12 +1,14 @@
-import { Atribuir, Construto, FimPara, FormatacaoEscrita, Literal, Logico, Super, TipoDe, Unario, Variavel } from '../../../construtos';
-import { Bloco, Classe, Const, Continua, Declaracao, Enquanto, Escolha, Escreva, EscrevaMesmaLinha, Expressao, Fazer, FuncaoDeclaracao, Importar, Leia, Para, ParaCada, Retorna, Se, Tente, Var } from '../../../declaracoes';
+import { Atribuir, Binario, Construto, FimPara, Literal, Logico, Super, TipoDe, Unario, Variavel } from '../../../construtos';
+import { Bloco, Classe, Const, Continua, Declaracao, Enquanto, Escolha, Escreva, EscrevaMesmaLinha, Expressao, Fazer, FuncaoDeclaracao, Leia, Para, ParaCada, Retorna, Se, Tente, Var } from '../../../declaracoes';
 import { EspacoVariaveis } from '../../../espaco-variaveis';
-import { InterpretadorInterface, SimboloInterface, VariavelInterface } from '../../../interfaces';
+import { SimboloInterface, VariavelInterface } from '../../../interfaces';
 import { ErroInterpretador } from '../../../interfaces/erros/erro-interpretador';
+import { InterpretadorInterfaceBirl } from '../../../interfaces/interpretador-interface-birl';
 import { PilhaEscoposExecucaoInterface } from '../../../interfaces/pilha-escopos-execucao-interface';
 import { RetornoInterpretador } from '../../../interfaces/retornos';
 import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../../../quebras';
-export declare class InterpretadorBirl implements InterpretadorInterface {
+import { InterpretadorBase } from '../../interpretador-base';
+export declare class InterpretadorBirl extends InterpretadorBase implements InterpretadorInterfaceBirl {
     diretorioBase: any;
     funcaoDeRetorno: Function;
     funcaoDeRetornoMesmaLinha: Function;
@@ -60,17 +62,17 @@ export declare class InterpretadorBirl implements InterpretadorInterface {
      * @returns Se ambos os operandos são números ou não.
      */
     protected verificarOperandosNumeros(operador: SimboloInterface, direita: VariavelInterface | any, esquerda: VariavelInterface | any): void;
-    visitarExpressaoBinaria(expressao: any): Promise<any>;
+    visitarExpressaoBinaria(expressao: Binario): Promise<any>;
     /**
      * Executa uma chamada de função, método ou classe.
      * @param expressao A expressão chamada.
      * @returns O resultado da chamada.
      */
     visitarExpressaoDeChamada(expressao: any): Promise<any>;
-    visitarDeclaracaoDeAtribuicao(expressao: Atribuir): void;
+    visitarDeclaracaoDeAtribuicao(expressao: Atribuir): Promise<void>;
     protected procurarVariavel(simbolo: SimboloInterface): any;
     visitarExpressaoDeVariavel(expressao: Variavel): any;
-    visitarDeclaracaoDeExpressao(declaracao: Expressao): void;
+    visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<void>;
     /**
      * Execução da leitura de valores da entrada configurada no
      * início da aplicação.
@@ -78,24 +80,11 @@ export declare class InterpretadorBirl implements InterpretadorInterface {
      * @returns Promise com o resultado da leitura.
      */
     visitarExpressaoLeia(expressao: Leia): Promise<any>;
-    /**
-     * Busca variáveis interpoladas.
-     * @param {texto} textoOriginal O texto original com as variáveis interpoladas.
-     * @returns Uma lista de variáveis interpoladas.
-     */
-    private buscarVariaveisInterpolacao;
-    /**
-     * Retira a interpolação de um texto.
-     * @param {texto} texto O texto
-     * @param {any[]} variaveis A lista de variaveis interpoladas
-     * @returns O texto com o valor das variaveis.
-     */
-    private retirarInterpolacao;
-    visitarExpressaoLiteral(expressao: Literal): any;
+    visitarExpressaoLiteral(expressao: Literal): Promise<any>;
     visitarExpressaoLogica(expressao: Logico): Promise<any>;
     visitarDeclaracaoPara(declaracao: Para): Promise<any>;
     visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any>;
-    protected eVerdadeiro(objeto: any): boolean;
+    eVerdadeiro(objeto: any): boolean;
     /**
      * Executa uma expressão Se, que tem uma condição, pode ter um bloco
      * Senão, e múltiplos blocos Senão-se.
@@ -103,20 +92,18 @@ export declare class InterpretadorBirl implements InterpretadorInterface {
      * @returns O resultado da avaliação do bloco cuja condição é verdadeira.
      */
     visitarDeclaracaoSe(declaracao: Se): Promise<any>;
-    visitarExpressaoFimPara(declaracao: FimPara): void;
-    visitarDeclaracaoFazer(declaracao: Fazer): void;
-    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): void;
-    visitarDeclaracaoEscolha(declaracao: Escolha): void;
-    visitarDeclaracaoTente(declaracao: Tente): void;
+    visitarExpressaoFimPara(declaracao: FimPara): Promise<void>;
+    visitarDeclaracaoFazer(declaracao: Fazer): Promise<void>;
+    visitarDeclaracaoEscolha(declaracao: Escolha): Promise<void>;
+    visitarDeclaracaoTente(declaracao: Tente): Promise<void>;
     visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<any>;
-    visitarDeclaracaoImportar(declaracao: Importar): void;
-    protected substituirValor(stringOriginal: string, novoValor: number | string | any, simboloTipo: string): Promise<string>;
-    protected resolveQuantidadeDeInterpolacoes(texto: Literal): Promise<RegExpMatchArray>;
+    substituirValor(stringOriginal: string, novoValor: number | string | any, simboloTipo: string): Promise<string>;
+    resolveQuantidadeDeInterpolacoes(texto: Literal): Promise<RegExpMatchArray>;
     verificaTipoDaInterpolação(dados: {
         tipo: string;
         valor: any;
     }): Promise<boolean>;
-    protected avaliarArgumentosEscreva(argumentos: Construto[]): Promise<string>;
+    avaliarArgumentosEscreva(argumentos: Construto[]): Promise<string>;
     /**
      * 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.
@@ -124,7 +111,7 @@ export declare class InterpretadorBirl implements InterpretadorInterface {
      * @returns Sempre nulo, por convenção de visita.
      */
     visitarDeclaracaoEscreva(declaracao: Escreva): Promise<any>;
-    visitarExpressaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): void;
+    visitarExpressaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): Promise<void>;
     visitarExpressaoBloco(declaracao: Bloco): Promise<any>;
     protected avaliacaoDeclaracaoVar(declaracao: Var): Promise<any>;
     /**
@@ -137,16 +124,15 @@ export declare class InterpretadorBirl implements InterpretadorInterface {
     visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra;
     visitarExpressaoSustar(declaracao?: any): SustarQuebra;
     visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
-    visitarExpressaoDeleguaFuncao(expressao: any): void;
     visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any>;
-    visitarExpressaoAcessoIndiceVariavel(expressao: any): void;
-    visitarExpressaoDefinirValor(expressao: any): void;
+    visitarExpressaoAcessoIndiceVariavel(expressao: any): Promise<void>;
+    visitarExpressaoDefinirValor(expressao: any): Promise<void>;
     visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): void;
-    visitarDeclaracaoClasse(declaracao: Classe): void;
-    visitarExpressaoAcessoMetodo(expressao: any): void;
+    visitarDeclaracaoClasse(declaracao: Classe): Promise<void>;
+    visitarExpressaoAcessoMetodo(expressao: any): Promise<void>;
     visitarExpressaoIsto(expressao: any): void;
-    visitarExpressaoDicionario(expressao: any): void;
-    visitarExpressaoVetor(expressao: any): void;
+    visitarExpressaoDicionario(expressao: any): Promise<void>;
+    visitarExpressaoVetor(expressao: any): Promise<void>;
     visitarExpressaoSuper(expressao: Super): void;
     paraTexto(objeto: any): any;
     /**

package/fontes/interpretador/dialetos/birl/interpretador-birl.js

@@ -34,10 +34,12 @@ const excecoes_1 = require("../../../excecoes");
 const quebras_1 = require("../../../quebras");
 const birl_1 = __importDefault(require("../../../tipos-de-simbolos/birl"));
 const inferenciador_1 = require("../../inferenciador");
+const interpretador_base_1 = require("../../interpretador-base");
 const pilha_escopos_execucao_1 = require("../../pilha-escopos-execucao");
 const comum = __importStar(require("./comum"));
-class InterpretadorBirl {
+class InterpretadorBirl extends interpretador_base_1.InterpretadorBase {
     constructor(diretorioBase, funcaoDeRetorno = null, funcaoDeRetornoMesmaLinha = null) {
+        super(diretorioBase, false, funcaoDeRetorno, funcaoDeRetornoMesmaLinha);
         this.funcaoDeRetorno = null;
         this.funcaoDeRetornoMesmaLinha = null;
         this.resultadoInterpretador = [];
@@ -301,10 +303,17 @@ class InterpretadorBirl {
                 : variavelEntidadeChamada;
             let argumentos = [];
             for (let i = 0; i < expressao.argumentos.length; i++) {
-                argumentos.push(await this.avaliar(expressao.argumentos[i]));
+                const variavelArgumento = expressao.argumentos[i];
+                const nomeArgumento = variavelArgumento.hasOwnProperty('simbolo') ?
+                    variavelArgumento.simbolo.lexema :
+                    undefined;
+                argumentos.push({
+                    nome: nomeArgumento,
+                    valor: await this.avaliar(variavelArgumento)
+                });
             }
             if (entidadeChamada instanceof estruturas_1.DeleguaModulo) {
-                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Entidade chamada é um módulo de Delégua. Provavelmente você quer chamar um de seus componentes?', expressao.linha));
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Entidade chamada é um módulo de Birl. Provavelmente você quer chamar um de seus componentes?', expressao.linha));
             }
             if (entidadeChamada instanceof estruturas_1.MetodoPrimitiva) {
                 const argumentosResolvidos = [];
@@ -338,8 +347,8 @@ class InterpretadorBirl {
                 if (parametros &&
                     parametros.length > 0 &&
                     parametros[parametros.length - 1].abrangencia === 'multiplo') {
-                    const novosArgumentos = argumentos.slice(0, parametros.length - 1);
-                    novosArgumentos.push(argumentos.slice(parametros.length - 1, argumentos.length));
+                    let novosArgumentos = argumentos.slice(0, parametros.length - 1);
+                    novosArgumentos = novosArgumentos.concat(argumentos.slice(parametros.length - 1, argumentos.length));
                     argumentos = novosArgumentos;
                 }
             }
@@ -380,7 +389,7 @@ class InterpretadorBirl {
             this.erros.push(erro);
         }
     }
-    visitarDeclaracaoDeAtribuicao(expressao) {
+    async visitarDeclaracaoDeAtribuicao(expressao) {
         throw new Error('Método não implementado.');
     }
     procurarVariavel(simbolo) {
@@ -389,7 +398,7 @@ class InterpretadorBirl {
     visitarExpressaoDeVariavel(expressao) {
         return this.procurarVariavel(expressao.simbolo);
     }
-    visitarDeclaracaoDeExpressao(declaracao) {
+    async visitarDeclaracaoDeExpressao(declaracao) {
         throw new Error('Método não implementado.');
     }
     /**
@@ -399,61 +408,10 @@ class InterpretadorBirl {
      * @returns Promise com o resultado da leitura.
      */
     async visitarExpressaoLeia(expressao) {
-        // const mensagem = expressao.argumentos && expressao.argumentos[0] ? expressao.argumentos[0].valor : '> ';
-        /**
-         * Em Birl não se usa mensagem junto com o prompt, normalmente se usa um Escreva antes.
-         */
-        const mensagem = '> ';
-        const promessaLeitura = () => new Promise((resolucao) => this.interfaceEntradaSaida.question(mensagem, (resposta) => {
-            resolucao(resposta);
-        }));
-        const valorLido = await promessaLeitura();
-        await comum.atribuirVariavel(this, expressao.argumentos[0], valorLido, expressao.argumentos[1].valor);
-        return;
+        await comum.visitarExpressaoLeia(this, expressao);
     }
-    /**
-     * Busca variáveis interpoladas.
-     * @param {texto} textoOriginal O texto original com as variáveis interpoladas.
-     * @returns Uma lista de variáveis interpoladas.
-     */
-    buscarVariaveisInterpolacao(textoOriginal) {
-        const variaveis = textoOriginal.match(this.regexInterpolacao);
-        return variaveis.map((s) => {
-            const nomeVariavel = s.replace(/[\$\{\}]*/g, '');
-            return {
-                variavel: nomeVariavel,
-                valor: this.pilhaEscoposExecucao.obterVariavelPorNome(nomeVariavel),
-            };
-        });
-    }
-    /**
-     * Retira a interpolação de um texto.
-     * @param {texto} texto O texto
-     * @param {any[]} variaveis A lista de variaveis interpoladas
-     * @returns O texto com o valor das variaveis.
-     */
-    retirarInterpolacao(texto, variaveis) {
-        const valoresVariaveis = variaveis.map((v) => ({
-            valorResolvido: this.pilhaEscoposExecucao.obterVariavelPorNome(v.variavel),
-            variavel: v.variavel,
-        }));
-        let textoFinal = texto;
-        valoresVariaveis.forEach((elemento) => {
-            const valorFinal = elemento.valorResolvido.hasOwnProperty('valor')
-                ? elemento.valorResolvido.valor
-                : elemento.valorResolvido;
-            textoFinal = textoFinal.replace('${' + elemento.variavel + '}', valorFinal);
-        });
-        return textoFinal;
-    }
-    visitarExpressaoLiteral(expressao) {
-        if (expressao.valor === birl_1.default.ADICAO) {
-            return 1;
-        }
-        if (expressao.valor === birl_1.default.SUBTRACAO) {
-            return -1;
-        }
-        return expressao.valor;
+    async visitarExpressaoLiteral(expressao) {
+        return comum.visitarExpressaoLiteral(expressao);
     }
     async visitarExpressaoLogica(expressao) {
         const esquerda = await this.avaliar(expressao.esquerda);
@@ -482,44 +440,7 @@ class InterpretadorBirl {
         return await this.avaliar(expressao.direita);
     }
     async visitarDeclaracaoPara(declaracao) {
-        if (declaracao.inicializador !== null) {
-            if (declaracao.inicializador instanceof Array) {
-                if (declaracao.inicializador[0] instanceof construtos_1.Variavel) {
-                    const valor = await this.avaliar(declaracao.inicializador[1]);
-                    this.pilhaEscoposExecucao.atribuirVariavel(declaracao.inicializador[0].simbolo, valor);
-                }
-            }
-            else {
-                await this.avaliar(declaracao.inicializador);
-            }
-        }
-        let retornoExecucao;
-        while (!(retornoExecucao instanceof quebras_1.Quebra)) {
-            if (declaracao.condicao !== null && !this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
-                break;
-            }
-            try {
-                retornoExecucao = await this.executar(declaracao.corpo);
-                if (retornoExecucao instanceof quebras_1.SustarQuebra) {
-                    return null;
-                }
-                if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
-                }
-            }
-            catch (erro) {
-                this.erros.push({
-                    erroInterno: erro,
-                    linha: declaracao.linha,
-                    hashArquivo: declaracao.hashArquivo,
-                });
-                return Promise.reject(erro);
-            }
-            if (declaracao.incrementar !== null) {
-                await this.avaliar(declaracao.incrementar);
-            }
-        }
-        return retornoExecucao;
+        return comum.visitarDeclaracaoPara(this, declaracao);
     }
     visitarDeclaracaoParaCada(declaracao) {
         throw new Error('Método não implementado.');
@@ -556,19 +477,19 @@ class InterpretadorBirl {
         }
         return null;
     }
-    visitarExpressaoFimPara(declaracao) {
-        throw new Error('Método não implementado.');
-    }
-    visitarDeclaracaoFazer(declaracao) {
+    async visitarExpressaoFimPara(declaracao) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoFormatacaoEscrita(declaracao) {
+    async visitarDeclaracaoFazer(declaracao) {
         throw new Error('Método não implementado.');
     }
-    visitarDeclaracaoEscolha(declaracao) {
+    // async visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
+    //     throw new Error('Método não implementado.');
+    // }
+    async visitarDeclaracaoEscolha(declaracao) {
         throw new Error('Método não implementado.');
     }
-    visitarDeclaracaoTente(declaracao) {
+    async visitarDeclaracaoTente(declaracao) {
         throw new Error('Método não implementado.');
     }
     async visitarDeclaracaoEnquanto(declaracao) {
@@ -594,101 +515,17 @@ class InterpretadorBirl {
         }
         return retornoExecucao;
     }
-    visitarDeclaracaoImportar(declaracao) {
-        throw new Error('Método não implementado.');
-    }
     async substituirValor(stringOriginal, novoValor, simboloTipo) {
-        let substituida = false;
-        let resultado = '';
-        for (let i = 0; i < stringOriginal.length; i++) {
-            if (stringOriginal[i] === '%' && stringOriginal[i + 1] === simboloTipo && !substituida) {
-                switch (simboloTipo) {
-                    case 'd':
-                    case 'i':
-                    case 'u':
-                    case 'f':
-                    case 'F':
-                    case 'e':
-                    case 'E':
-                    case 'g':
-                    case 'G':
-                    case 'x':
-                    case 'X':
-                    case 'o':
-                    case 'c':
-                    case 's':
-                    case 'p':
-                        resultado += novoValor.hasOwnProperty('valor') ? novoValor.valor : novoValor;
-                        break;
-                    default:
-                        resultado += stringOriginal[i];
-                        break;
-                }
-                substituida = true;
-                i++;
-            }
-            else {
-                resultado += stringOriginal[i];
-            }
-        }
-        return resultado;
+        return comum.substituirValor(stringOriginal, novoValor, simboloTipo);
     }
     async resolveQuantidadeDeInterpolacoes(texto) {
-        const stringOriginal = texto.valor;
-        const regex = /%[a-zA-Z]/g;
-        const matches = stringOriginal.match(regex);
-        return matches;
+        return comum.resolveQuantidadeDeInterpolacoes(texto);
     }
     async verificaTipoDaInterpolação(dados) {
-        switch (dados.tipo) {
-            case 'd':
-            case 'i':
-            case 'u':
-                const valor = dados.valor.hasOwnProperty('valor') ? dados.valor.valor : dados.valor;
-                if (typeof valor !== 'number') {
-                    throw new Error('O valor interpolado não é um número.');
-                }
-                return true;
-            case 'c':
-            case 's':
-                const valorString = dados.valor.hasOwnProperty('valor') ? dados.valor.valor : dados.valor;
-                if (typeof valorString !== 'string') {
-                    throw new Error('O valor interpolado não é um caractere.');
-                }
-                return true;
-            default:
-                throw new Error('Tipo de interpolação não suportado.');
-        }
+        return comum.verificaTipoDaInterpolação(dados);
     }
     async avaliarArgumentosEscreva(argumentos) {
-        let formatoTexto = '';
-        let quantidadeInterpolacoes;
-        if (argumentos.length < 1) {
-            throw new Error('Escreva precisa de pelo menos um argumento.');
-        }
-        if (!(argumentos[0] instanceof construtos_1.Literal)) {
-            throw new Error('O primeiro argumento de Escreva precisa ser uma string.');
-        }
-        quantidadeInterpolacoes = await this.resolveQuantidadeDeInterpolacoes(argumentos[0]);
-        const resultadoAvaliacaoLiteral = await this.avaliar(argumentos[0]);
-        if (quantidadeInterpolacoes === null) {
-            formatoTexto = (resultadoAvaliacaoLiteral === null || resultadoAvaliacaoLiteral === void 0 ? void 0 : resultadoAvaliacaoLiteral.hasOwnProperty('valor')) ? resultadoAvaliacaoLiteral.valor : resultadoAvaliacaoLiteral;
-            return formatoTexto;
-        }
-        if (!(argumentos.length - 1 === quantidadeInterpolacoes.length)) {
-            throw new Error('Quantidade de argumentos não bate com quantidade de interpolacoes.');
-        }
-        formatoTexto = resultadoAvaliacaoLiteral;
-        for (let i = 0; i < quantidadeInterpolacoes.length; i++) {
-            const dados = {
-                tipo: quantidadeInterpolacoes[i].replace('%', ''),
-                valor: await this.avaliar(argumentos[i + 1])
-            };
-            if (this.verificaTipoDaInterpolação(dados)) {
-                formatoTexto = await this.substituirValor(formatoTexto, dados.valor, dados.tipo);
-            }
-        }
-        return formatoTexto.trimEnd();
+        return comum.avaliarArgumentosEscreva(this, argumentos);
     }
     /**
      * Execução de uma escrita na saída configurada, que pode ser `console` (padrão) ou
@@ -710,7 +547,7 @@ class InterpretadorBirl {
             });
         }
     }
-    visitarExpressaoEscrevaMesmaLinha(declaracao) {
+    async visitarExpressaoEscrevaMesmaLinha(declaracao) {
         throw new Error('Método não implementado.');
     }
     async visitarExpressaoBloco(declaracao) {
@@ -758,35 +595,35 @@ class InterpretadorBirl {
             valor = await this.avaliar(declaracao.valor);
         return new quebras_1.RetornoQuebra(valor);
     }
-    visitarExpressaoDeleguaFuncao(expressao) {
-        throw new Error('Método não implementado.');
-    }
+    // async visitarExpressaoDeleguaFuncao(expressao: any) {
+    //     throw new Error('Método não implementado.');
+    // }
     visitarExpressaoAtribuicaoPorIndice(expressao) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoAcessoIndiceVariavel(expressao) {
+    async visitarExpressaoAcessoIndiceVariavel(expressao) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoDefinirValor(expressao) {
+    async visitarExpressaoDefinirValor(expressao) {
         throw new Error('Método não implementado.');
     }
     visitarDeclaracaoDefinicaoFuncao(declaracao) {
         const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
     }
-    visitarDeclaracaoClasse(declaracao) {
+    async visitarDeclaracaoClasse(declaracao) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoAcessoMetodo(expressao) {
+    async visitarExpressaoAcessoMetodo(expressao) {
         throw new Error('Método não implementado.');
     }
     visitarExpressaoIsto(expressao) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoDicionario(expressao) {
+    async visitarExpressaoDicionario(expressao) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoVetor(expressao) {
+    async visitarExpressaoVetor(expressao) {
         throw new Error('Método não implementado.');
     }
     visitarExpressaoSuper(expressao) {
@@ -867,37 +704,7 @@ class InterpretadorBirl {
         }
     }
     async interpretar(declaracoes, manterAmbiente) {
-        this.erros = [];
-        const escopoExecucao = {
-            declaracoes: declaracoes,
-            declaracaoAtual: 0,
-            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
-            finalizado: false,
-            tipo: 'outro',
-            emLacoRepeticao: false,
-        };
-        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-        try {
-            const retornoOuErro = await this.executarUltimoEscopo(manterAmbiente);
-            if (retornoOuErro instanceof excecoes_1.ErroEmTempoDeExecucao) {
-                this.erros.push(retornoOuErro);
-            }
-        }
-        catch (erro) {
-            this.erros.push({
-                erroInterno: erro,
-                linha: -1,
-                hashArquivo: -1,
-            });
-        }
-        finally {
-            const retorno = {
-                erros: this.erros,
-                resultado: this.resultadoInterpretador,
-            };
-            this.resultadoInterpretador = [];
-            return retorno;
-        }
+        return comum.interpretar(this, declaracoes, manterAmbiente);
     }
 }
 exports.InterpretadorBirl = InterpretadorBirl;