@designliquido/delegua 1.17.0 → 1.17.2

package/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InterpretadorPortugolIpt = void 0;
+const construtos_1 = require("../../../construtos");
+const declaracoes_1 = require("../../../declaracoes");
 const espaco_memoria_1 = require("../../espaco-memoria");
 const estruturas_1 = require("../../estruturas");
 const excecoes_1 = require("../../../excecoes");
@@ -34,145 +36,65 @@ class InterpretadorPortugolIpt {
         };
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
     }
-    /* istanbul ignore next */
-    visitarExpressaoTuplaN(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoAcessoIntervaloVariavel(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarDeclaracaoTextoDocumentacao(declaracao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoSeparador(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoComentario(expressao) {
-        throw new Error('Método não implementado.');
-    }
+    // ── Utilitários ─────────────────────────────────────────────────────────────
     resolverValor(objeto) {
-        if (objeto === null || objeto === undefined) {
+        if (objeto === null || objeto === undefined)
             return objeto;
-        }
-        if (objeto.hasOwnProperty('valor')) {
+        if (objeto.hasOwnProperty('valor'))
             return objeto.valor;
-        }
         return objeto;
     }
-    /* istanbul ignore next */
-    visitarExpressaoArgumentoReferenciaFuncao(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoReferenciaFuncao(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoAcessoMetodo(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoAcessoPropriedade(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    visitarDeclaracaoComentario(declaracao) {
-        return Promise.resolve();
-    }
-    /* istanbul ignore next */
-    visitarDeclaracaoTendoComo(declaracao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarDeclaracaoInicioAlgoritmo(declaracao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarDeclaracaoCabecalhoPrograma(declaracao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoTupla(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoAcessoElementoMatriz(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
-        throw new Error('Método não implementado.');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoExpressaoRegular(expressao) {
-        throw new Error('Método não implementado.');
+    eVerdadeiro(objeto) {
+        if (objeto === null)
+            return false;
+        if (typeof objeto === 'boolean')
+            return Boolean(objeto);
+        if (objeto.hasOwnProperty('valor'))
+            return Boolean(objeto.valor);
+        return true;
     }
-    /* istanbul ignore next */
-    visitarExpressaoTipoDe(expressao) {
-        throw new Error('Método não implementado.');
+    eIgual(esquerda, direita) {
+        if (esquerda === null && direita === null)
+            return true;
+        if (esquerda === null)
+            return false;
+        return esquerda === direita;
     }
-    /* istanbul ignore next */
-    visitarExpressaoFalhar(expressao) {
-        throw new Error('Método não implementado.');
+    verificarOperandosNumeros(operador, direita, esquerda) {
+        const valorDireita = this.resolverValor(direita);
+        const valorEsquerda = this.resolverValor(esquerda);
+        const tipoDireita = direita?.tipo ?? (typeof valorDireita === 'number' ? 'número' : String(NaN));
+        const tipoEsquerda = esquerda?.tipo ?? (typeof valorEsquerda === 'number' ? 'número' : String(NaN));
+        const tiposNumericos = ['inteiro', 'numero', 'número', 'real'];
+        const eNumericoOuQualquer = (tipo, valor) => tiposNumericos.includes(tipo.toLowerCase()) ||
+            tipo === 'qualquer' && typeof valor === 'number';
+        if (eNumericoOuQualquer(tipoDireita, valorDireita) && eNumericoOuQualquer(tipoEsquerda, valorEsquerda))
+            return;
+        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
     }
-    /* istanbul ignore next */
-    visitarDeclaracaoParaCada(declaracao) {
-        throw new Error('Método não implementado.');
+    paraTexto(objeto) {
+        if (objeto === null || objeto === undefined)
+            return 'nulo';
+        if (typeof objeto === 'boolean')
+            return objeto ? 'verdadeiro' : 'falso';
+        if (objeto instanceof Date) {
+            return Intl.DateTimeFormat('pt', { dateStyle: 'full', timeStyle: 'full' }).format(objeto);
+        }
+        if (Array.isArray(objeto))
+            return objeto;
+        if (objeto.valor instanceof estruturas_1.ObjetoPadrao)
+            return objeto.valor.paraTexto();
+        if (typeof objeto === 'object')
+            return JSON.stringify(objeto);
+        return objeto.toString();
     }
+    // ── Expressões ──────────────────────────────────────────────────────────────
     visitarExpressaoLiteral(expressao) {
         return Promise.resolve(expressao.valor);
     }
-    async avaliar(expressao) {
-        // Descomente o código abaixo quando precisar detectar expressões undefined ou nulas.
-        // Por algum motivo o depurador do VSCode não funciona direito aqui
-        // com breakpoint condicional.
-        /* if (expressao === null || expressao === undefined) {
-            console.log('Aqui');
-        } */
-        return await expressao.aceitar(this);
-    }
     async visitarExpressaoAgrupamento(expressao) {
         return await this.avaliar(expressao.expressao);
     }
-    /* istanbul ignore next */
-    visitarExpressaoUnaria(expressao) {
-        throw new Error('Método não implementado');
-    }
-    /**
-     * Verifica se operandos são números, que podem ser tanto variáveis puras do JavaScript
-     * (neste caso, `number`), ou podem ser variáveis de Delégua com inferência (`VariavelInterface`).
-     * @param operador O símbolo do operador.
-     * @param direita O operando direito.
-     * @param esquerda O operando esquerdo.
-     * @returns Se ambos os operandos são números ou não.
-     */
-    verificarOperandosNumeros(operador, direita, esquerda) {
-        const tipoDireita = direita.tipo
-            ? direita.tipo
-            : typeof direita === 'number'
-                ? 'número'
-                : String(NaN);
-        const tipoEsquerda = esquerda.tipo
-            ? esquerda.tipo
-            : typeof esquerda === 'number'
-                ? 'número'
-                : String(NaN);
-        const tiposNumericos = ['inteiro', 'numero', 'número', 'real'];
-        if (tiposNumericos.includes(tipoDireita.toLowerCase()) &&
-            tiposNumericos.includes(tipoEsquerda.toLowerCase()))
-            return;
-        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
-    }
-    eIgual(esquerda, direita) {
-        if (esquerda === null && direita === null)
-            return true;
-        if (esquerda === null)
-            return false;
-        return esquerda === direita;
-    }
     async visitarExpressaoBinaria(expressao) {
         try {
             const esquerda = await this.avaliar(expressao.esquerda);
@@ -185,6 +107,9 @@ class InterpretadorPortugolIpt {
             const tipoDireito = direita?.hasOwnProperty('tipo')
                 ? direita.tipo
                 : (0, inferenciador_1.inferirTipoVariavel)(direita);
+            const tiposNumericos = ['inteiro', 'numero', 'número', 'real'];
+            const ambosNumericos = (tiposNumericos.includes(tipoEsquerdo) || tipoEsquerdo === 'qualquer' && typeof valorEsquerdo === 'number') &&
+                (tiposNumericos.includes(tipoDireito) || tipoDireito === 'qualquer' && typeof valorDireito === 'number');
             switch (expressao.operador.tipo) {
                 case portugol_ipt_1.default.EXPONENCIACAO:
                     this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
@@ -205,12 +130,10 @@ class InterpretadorPortugolIpt {
                     this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                     return Number(valorEsquerdo) - Number(valorDireito);
                 case portugol_ipt_1.default.ADICAO:
-                    if (tipoEsquerdo === 'número' && tipoDireito === 'número') {
+                    if (ambosNumericos) {
                         return Number(valorEsquerdo) + Number(valorDireito);
                     }
-                    else {
-                        return String(valorEsquerdo) + String(valorDireito);
-                    }
+                    return String(valorEsquerdo) + String(valorDireito);
                 case portugol_ipt_1.default.DIVISAO:
                     this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                     return Number(valorEsquerdo) / Number(valorDireito);
@@ -219,15 +142,11 @@ class InterpretadorPortugolIpt {
                     return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
                 case portugol_ipt_1.default.MULTIPLICACAO:
                     if (tipoEsquerdo === 'texto' || tipoDireito === 'texto') {
-                        // Sem ambos os valores resolvem como texto, multiplica normal.
-                        // Se apenas um resolve como texto, o outro repete o
-                        // texto n vezes, sendo n o valor do outro.
                         if (tipoEsquerdo === 'texto' && tipoDireito === 'texto') {
                             return Number(valorEsquerdo) * Number(valorDireito);
                         }
-                        if (tipoEsquerdo === 'texto') {
+                        if (tipoEsquerdo === 'texto')
                             return valorEsquerdo.repeat(Number(valorDireito));
-                        }
                         return valorDireito.repeat(Number(valorEsquerdo));
                     }
                     return Number(valorEsquerdo) * Number(valorDireito);
@@ -244,125 +163,155 @@ class InterpretadorPortugolIpt {
             return Promise.reject(erro);
         }
     }
-    /* istanbul ignore next */
-    visitarExpressaoDeChamada(expressao) {
-        throw new Error('Método não implementado');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoDeAtribuicao(expressao) {
-        throw new Error('Método não implementado');
+    async visitarExpressaoLogica(expressao) {
+        const esquerda = await this.avaliar(expressao.esquerda);
+        switch (expressao.operador.tipo) {
+            case portugol_ipt_1.default.OU:
+                if (this.eVerdadeiro(esquerda))
+                    return true;
+                return this.eVerdadeiro(await this.avaliar(expressao.direita));
+            case portugol_ipt_1.default.XOU: {
+                const ve = this.eVerdadeiro(esquerda);
+                const vd = this.eVerdadeiro(await this.avaliar(expressao.direita));
+                return ve !== vd;
+            }
+            case portugol_ipt_1.default.E:
+                if (!this.eVerdadeiro(esquerda))
+                    return false;
+                return this.eVerdadeiro(await this.avaliar(expressao.direita));
+        }
+        return await this.avaliar(expressao.direita);
+    }
+    async visitarExpressaoUnaria(expressao) {
+        const operando = await this.avaliar(expressao.operando);
+        const valor = this.resolverValor(operando);
+        switch (expressao.operador.tipo) {
+            case portugol_ipt_1.default.SUBTRACAO:
+                return -Number(valor);
+            case portugol_ipt_1.default.NEGACAO:
+            case portugol_ipt_1.default.NAO:
+                return !this.eVerdadeiro(valor);
+        }
+        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, `Operador unário desconhecido: ${expressao.operador.lexema}`, expressao.operador.linha);
     }
-    procurarVariavel(simbolo) {
-        return this.pilhaEscoposExecucao.obterValorVariavel(simbolo);
+    async visitarExpressaoDeAtribuicao(expressao) {
+        const valor = await this.avaliar(expressao.valor);
+        const valorFinal = this.resolverValor(valor);
+        const alvo = expressao.alvo;
+        this.pilhaEscoposExecucao.atribuirVariavel(alvo.simbolo, valorFinal);
+        return valorFinal;
     }
     visitarExpressaoDeVariavel(expressao) {
-        return this.procurarVariavel(expressao.simbolo);
-    }
-    async visitarDeclaracaoDeExpressao(declaracao) {
-        return declaracao.expressao.aceitar(this);
+        return this.pilhaEscoposExecucao.obterValorVariavel(expressao.simbolo);
     }
-    /**
-     * 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) {
-        const mensagem = expressao.argumentos && expressao.argumentos[0] ? expressao.argumentos[0].valor : '> ';
-        return new Promise((resolucao) => this.interfaceEntradaSaida.question(mensagem, (resposta) => {
-            resolucao(resposta);
-        }));
-    }
-    /* istanbul ignore next */
-    visitarExpressaoLogica(expressao) {
-        throw new Error('Método não implementado');
-    }
-    eVerdadeiro(objeto) {
-        if (objeto === null)
-            return false;
-        if (typeof objeto === 'boolean')
-            return Boolean(objeto);
-        if (objeto.hasOwnProperty('valor')) {
-            return Boolean(objeto.valor);
-        }
-        return true;
-    }
-    /**
-     * Executa uma expressão Se, que tem uma condição, pode ter um bloco
-     * Senão, e múltiplos blocos Senão-se.
-     * @param declaracao A declaração Se.
-     * @returns O resultado da avaliação do bloco cuja condição é verdadeira.
-     */
-    async visitarDeclaracaoSe(declaracao) {
-        if (this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
-            return await this.executar(declaracao.caminhoEntao);
-        }
-        if (declaracao.caminhoSenao !== null) {
-            return await this.executar(declaracao.caminhoSenao);
+        for (const arg of expressao.argumentos) {
+            const resposta = await new Promise((resolve) => this.interfaceEntradaSaida.question('> ', (r) => resolve(r)));
+            // arg é um Expressao (declaração) envolvendo um Variavel
+            const construto = arg instanceof declaracoes_1.Expressao
+                ? arg.expressao
+                : arg;
+            if (construto instanceof construtos_1.Variavel) {
+                const valorConvertido = typeof resposta === 'string' && !Number.isNaN(Number(resposta))
+                    ? Number(resposta)
+                    : resposta;
+                this.pilhaEscoposExecucao.atribuirVariavel(construto.simbolo, valorConvertido);
+            }
         }
         return null;
     }
-    /* istanbul ignore next */
-    visitarDeclaracaoPara(declaracao) {
-        return Promise.reject('Método não implementado');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoFimPara(declaracao) {
-        throw new Error('Método não implementado');
-    }
-    /* istanbul ignore next */
-    visitarDeclaracaoFazer(declaracao) {
-        throw new Error('Método não implementado');
-    }
     async visitarExpressaoFormatacaoEscrita(declaracao) {
-        let resultado = '';
         const conteudo = await this.avaliar(declaracao.expressao);
         const valorConteudo = this.resolverValor(conteudo);
-        const tipoConteudo = conteudo.hasOwnProperty('tipo')
-            ? conteudo.tipo
-            : typeof conteudo;
-        resultado = valorConteudo;
+        const tipoConteudo = conteudo.hasOwnProperty('tipo') ? conteudo.tipo : typeof conteudo;
+        let resultado = valorConteudo;
         if (['número', 'number'].includes(tipoConteudo) && declaracao.casasDecimais > 0) {
             resultado = valorConteudo.toLocaleString('pt', {
                 maximumFractionDigits: declaracao.casasDecimais,
             });
         }
-        if (declaracao.espacos > 0) {
+        if (declaracao.espacos > 0)
             resultado += ' '.repeat(declaracao.espacos);
-        }
         return resultado;
     }
-    /* istanbul ignore next */
-    visitarDeclaracaoEscolha(declaracao) {
-        throw new Error('Método não implementado');
-    }
-    /* istanbul ignore next */
-    visitarDeclaracaoTente(declaracao) {
-        throw new Error('Método não implementado');
-    }
-    /* istanbul ignore next */
-    visitarDeclaracaoEnquanto(declaracao) {
-        throw new Error('Método não implementado');
-    }
-    /* istanbul ignore next */
-    visitarDeclaracaoImportar(declaracao) {
-        throw new Error('Método não implementado');
+    // ── Acesso a vetores ────────────────────────────────────────────────────────
+    async visitarExpressaoAcessoIndiceVariavel(expressao) {
+        const objetoAvaliado = await this.avaliar(expressao.entidadeChamada);
+        const indiceAvaliado = await this.avaliar(expressao.indice);
+        const objeto = this.resolverValor(objetoAvaliado);
+        const indice = this.resolverValor(indiceAvaliado);
+        if (Array.isArray(objeto)) {
+            if (indice < 0 || indice >= objeto.length) {
+                return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha));
+            }
+            return objeto[indice];
+        }
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Acesso por índice só é suportado em vetores.', expressao.linha));
+    }
+    async visitarExpressaoAtribuicaoPorIndice(expressao) {
+        const objetoAvaliado = await this.avaliar(expressao.objeto);
+        const indiceAvaliado = await this.avaliar(expressao.indice);
+        const valorAvaliado = await this.avaliar(expressao.valor);
+        const objeto = this.resolverValor(objetoAvaliado);
+        const indice = this.resolverValor(indiceAvaliado);
+        const valor = this.resolverValor(valorAvaliado);
+        if (Array.isArray(objeto)) {
+            objeto[indice] = valor;
+            return valor;
+        }
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(null, 'Atribuição por índice só é suportada em vetores.', expressao.linha));
     }
-    async avaliarArgumentosEscreva(argumentos) {
-        let formatoTexto = '';
-        for (const argumento of argumentos) {
-            const resultadoAvaliacao = await this.avaliar(argumento);
-            let valor = this.resolverValor(resultadoAvaliacao);
-            formatoTexto += `${this.paraTexto(valor)} `;
+    // ── Chamadas de funções embutidas ───────────────────────────────────────────
+    async visitarExpressaoDeChamada(expressao) {
+        const callee = expressao.entidadeChamada;
+        if (!(callee instanceof construtos_1.Variavel)) {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(null, 'Chamada de função inválida.', expressao.linha));
         }
-        return formatoTexto.trimEnd();
+        const nome = callee.simbolo.lexema.toUpperCase();
+        const args = [];
+        for (const arg of expressao.argumentos) {
+            args.push(this.resolverValor(await this.avaliar(arg)));
+        }
+        return this.chamarFuncaoEmbutida(nome, args, expressao.linha);
+    }
+    chamarFuncaoEmbutida(nome, args, linha) {
+        switch (nome) {
+            // ── 0 argumentos ──
+            case 'ALEATORIO': return Math.random();
+            // ── 1 argumento ──
+            case 'SEN': return Math.sin(args[0]);
+            case 'COS': return Math.cos(args[0]);
+            case 'TAN': return Math.tan(args[0]);
+            case 'CTG': return 1 / Math.tan(args[0]);
+            case 'ASEN': return Math.asin(args[0]);
+            case 'ACOS': return Math.acos(args[0]);
+            case 'ATAN': return Math.atan(args[0]);
+            case 'ACTG': return 1 / Math.atan(args[0]);
+            case 'SENH': return Math.sinh(args[0]);
+            case 'COSH': return Math.cosh(args[0]);
+            case 'TANH': return Math.tanh(args[0]);
+            case 'CTGH': return 1 / Math.tanh(args[0]);
+            case 'EXP': return Math.exp(args[0]);
+            case 'ABS': return Math.abs(args[0]);
+            case 'RAIZ': return Math.sqrt(args[0]);
+            case 'LOG': return Math.log10(args[0]);
+            case 'LN': return Math.log(args[0]);
+            case 'INT': return Math.trunc(args[0]);
+            case 'FRAC': return args[0] - Math.trunc(args[0]);
+            case 'ARRED': return Math.round(args[0]);
+            // ── 2 argumentos ──
+            case 'POTENCIA': return Math.pow(args[0], args[1]);
+            // ── Texto ──
+            case 'COMPRIMENTO': return String(args[0]).length;
+            case 'LETRA': return String(args[0]).charAt(Number(args[1]));
+            default:
+                throw new excecoes_1.ErroEmTempoDeExecucao(null, `Função embutida desconhecida: '${nome}'.`, linha);
+        }
+    }
+    // ── Declarações ─────────────────────────────────────────────────────────────
+    async visitarDeclaracaoDeExpressao(declaracao) {
+        return declaracao.expressao.aceitar(this);
     }
-    /**
-     * 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.
-     * @param declaracao A declaração.
-     * @returns Sempre nulo, por convenção de visita.
-     */
     async visitarDeclaracaoEscreva(declaracao) {
         try {
             const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
@@ -370,11 +319,7 @@ class InterpretadorPortugolIpt {
             return null;
         }
         catch (erro) {
-            this.erros.push({
-                erroInterno: erro,
-                linha: declaracao.linha,
-                hashArquivo: declaracao.hashArquivo,
-            });
+            this.erros.push({ erroInterno: erro, linha: declaracao.linha, hashArquivo: declaracao.hashArquivo });
         }
     }
     async visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
@@ -384,157 +329,314 @@ class InterpretadorPortugolIpt {
             return null;
         }
         catch (erro) {
-            this.erros.push({
-                erroInterno: erro,
-                linha: declaracao.linha,
-                hashArquivo: declaracao.hashArquivo,
-            });
+            this.erros.push({ erroInterno: erro, linha: declaracao.linha, hashArquivo: declaracao.hashArquivo });
         }
     }
-    /* istanbul ignore next */
-    executarBloco(declaracoes, ambiente) {
-        throw new Error('Método não implementado');
-    }
-    /* istanbul ignore next */
-    visitarExpressaoBloco(declaracao) {
-        throw new Error('Método não implementado');
+    async avaliarArgumentosEscreva(argumentos) {
+        let formatoTexto = '';
+        for (const argumento of argumentos) {
+            const resultado = await this.avaliar(argumento);
+            formatoTexto += `${this.paraTexto(this.resolverValor(resultado))} `;
+        }
+        return formatoTexto.trimEnd();
     }
-    async avaliacaoDeclaracaoVar(declaracao) {
-        let valorOuOutraVariavel = null;
+    async visitarDeclaracaoVar(declaracao) {
+        let valorFinal = null;
         if (declaracao.inicializador !== null) {
-            valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
+            const avaliado = await this.avaliar(declaracao.inicializador);
+            if (avaliado !== null && avaliado !== undefined) {
+                valorFinal = this.resolverValor(avaliado);
+            }
         }
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal, declaracao.tipo);
+        return null;
+    }
+    async visitarDeclaracaoConst(declaracao) {
         let valorFinal = null;
-        if (valorOuOutraVariavel !== null && valorOuOutraVariavel !== undefined) {
-            valorFinal = this.resolverValor(valorOuOutraVariavel);
+        if (declaracao.inicializador !== null) {
+            const avaliado = await this.avaliar(declaracao.inicializador);
+            if (avaliado !== null && avaliado !== undefined) {
+                valorFinal = this.resolverValor(avaliado);
+            }
         }
-        return valorFinal;
+        this.pilhaEscoposExecucao.definirConstante(declaracao.simbolo.lexema, valorFinal, declaracao.tipo);
+        return null;
     }
-    /**
-     * Executa expressão de definição de variável.
-     * @param declaracao A declaração Var
-     * @returns Sempre retorna nulo.
-     */
-    async visitarDeclaracaoVar(declaracao) {
-        const valorFinal = await this.avaliacaoDeclaracaoVar(declaracao);
-        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal, declaracao.tipo);
+    async visitarDeclaracaoSe(declaracao) {
+        if (this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+            return await this.executar(declaracao.caminhoEntao);
+        }
+        if (declaracao.caminhoSenao !== null) {
+            return await this.executar(declaracao.caminhoSenao);
+        }
+        return null;
+    }
+    async visitarDeclaracaoEnquanto(declaracao) {
+        while (this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+            try {
+                const resultado = await this.executar(declaracao.corpo);
+                if (resultado instanceof quebras_1.SustarQuebra)
+                    return null;
+                if (resultado instanceof quebras_1.ContinuarQuebra)
+                    continue;
+                if (resultado instanceof quebras_1.Quebra)
+                    break;
+            }
+            catch (erro) {
+                this.erros.push({ erroInterno: erro, linha: declaracao.linha, hashArquivo: declaracao.hashArquivo });
+                return Promise.reject(erro);
+            }
+        }
         return null;
     }
+    async visitarDeclaracaoPara(declaracao) {
+        const inicializador = Array.isArray(declaracao.inicializador)
+            ? declaracao.inicializador[0]
+            : declaracao.inicializador;
+        if (inicializador)
+            await this.avaliar(inicializador);
+        while (true) {
+            if (declaracao.condicao && !this.eVerdadeiro(await this.avaliar(declaracao.condicao)))
+                break;
+            try {
+                const resultado = await this.executar(declaracao.corpo);
+                if (resultado instanceof quebras_1.SustarQuebra)
+                    return null;
+                if (resultado instanceof quebras_1.ContinuarQuebra) { /* continua para incremento */ }
+                else if (resultado instanceof quebras_1.Quebra)
+                    break;
+            }
+            catch (erro) {
+                this.erros.push({ erroInterno: erro, linha: declaracao.linha, hashArquivo: declaracao.hashArquivo });
+                return Promise.reject(erro);
+            }
+            if (declaracao.incrementar)
+                await this.avaliar(declaracao.incrementar);
+        }
+        return null;
+    }
+    async visitarDeclaracaoFazer(declaracao) {
+        do {
+            try {
+                const resultado = await this.executar(declaracao.caminhoFazer);
+                if (resultado instanceof quebras_1.SustarQuebra)
+                    return null;
+                if (resultado instanceof quebras_1.ContinuarQuebra)
+                    continue;
+                if (resultado instanceof quebras_1.Quebra)
+                    break;
+            }
+            catch (erro) {
+                this.erros.push({ erroInterno: erro, linha: declaracao.linha, hashArquivo: declaracao.hashArquivo });
+                return Promise.reject(erro);
+            }
+        } while (this.eVerdadeiro(await this.avaliar(declaracao.condicaoEnquanto)));
+        return null;
+    }
+    async visitarDeclaracaoEscolha(declaracao) {
+        const valorCondicao = this.resolverValor(await this.avaliar(declaracao.identificadorOuLiteral));
+        let encontrado = false;
+        for (const caminho of declaracao.caminhos) {
+            for (const condicao of caminho.condicoes) {
+                const valorCondicaoAvaliado = this.resolverValor(await this.avaliar(condicao));
+                if (valorCondicaoAvaliado === valorCondicao) {
+                    encontrado = true;
+                    await this.executarBloco(caminho.declaracoes);
+                    break;
+                }
+            }
+            if (encontrado)
+                break;
+        }
+        if (!encontrado && declaracao.caminhoPadrao) {
+            await this.executarBloco(declaracao.caminhoPadrao.declaracoes);
+        }
+        return null;
+    }
+    visitarDeclaracaoComentario(declaracao) {
+        return Promise.resolve();
+    }
+    // ── Bloco e escopo ───────────────────────────────────────────────────────────
+    async executarBloco(declaracoes, ambiente) {
+        const escopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            espacoMemoria: ambiente || new espaco_memoria_1.EspacoMemoria(),
+            finalizado: false,
+            tipo: 'outro',
+            emLacoRepeticao: false,
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        return await this.executarUltimoEscopo();
+    }
+    async visitarExpressaoBloco(declaracao) {
+        return await this.executarBloco(declaracao.declaracoes);
+    }
+    // ── Métodos obrigatórios da interface não usados em Portugol IPT ────────────
     /* istanbul ignore next */
-    visitarDeclaracaoVarMultiplo(declaracao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoTuplaN(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarDeclaracaoConst(declaracao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoAcessoIntervaloVariavel(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarDeclaracaoConstMultiplo(declaracao) {
-        throw new Error('Método não implementado');
+    visitarDeclaracaoTextoDocumentacao(_declaracao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoContinua(declaracao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoSeparador(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoSustar(declaracao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoComentario(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoRetornar(declaracao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoArgumentoReferenciaFuncao(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoFuncaoConstruto(expressao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoReferenciaFuncao(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoAtribuicaoPorIndice(expressao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoAcessoMetodo(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoAcessoIndiceVariavel(expressao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoAcessoPropriedade(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoDefinirValor(expressao) {
-        throw new Error('Método não implementado');
+    visitarDeclaracaoTendoComo(_declaracao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarDeclaracaoDefinicaoFuncao(declaracao) {
-        throw new Error('Método não implementado');
+    visitarDeclaracaoInicioAlgoritmo(_declaracao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarDeclaracaoClasse(declaracao) {
-        throw new Error('Método não implementado');
+    visitarDeclaracaoCabecalhoPrograma(_declaracao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoAcessoMetodoOuPropriedade(expressao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoTupla(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoIsto(expressao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoAcessoElementoMatriz(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoDicionario(expressao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoAtribuicaoPorIndicesMatriz(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoVetor(expressao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoExpressaoRegular(_expressao) {
+        throw new Error('Método não implementado.');
     }
     /* istanbul ignore next */
-    visitarExpressaoSuper(expressao) {
-        throw new Error('Método não implementado');
+    visitarExpressaoTipoDe(_expressao) {
+        throw new Error('Método não implementado.');
     }
-    paraTexto(objeto) {
-        if (objeto === null || objeto === undefined)
-            return 'nulo';
-        if (typeof objeto === 'boolean') {
-            return objeto ? 'verdadeiro' : 'falso';
-        }
-        if (objeto instanceof Date) {
-            const formato = Intl.DateTimeFormat('pt', {
-                dateStyle: 'full',
-                timeStyle: 'full',
-            });
-            return formato.format(objeto);
+    /* istanbul ignore next */
+    visitarExpressaoFalhar(_expressao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarDeclaracaoParaCada(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarDeclaracaoVarMultiplo(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarDeclaracaoConstMultiplo(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarExpressaoContinua(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarExpressaoSustar(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarExpressaoRetornar(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarExpressaoFuncaoConstruto(_expressao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarExpressaoDefinirValor(_expressao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarDeclaracaoDefinicaoFuncao(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarDeclaracaoClasse(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarExpressaoAcessoMetodoOuPropriedade(_expressao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarExpressaoIsto(_expressao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarExpressaoDicionario(_expressao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoVetor(expressao) {
+        const valores = [];
+        for (const elemento of expressao.valores) {
+            const avaliado = await this.avaliar(elemento);
+            valores.push(this.resolverValor(avaliado));
         }
-        if (Array.isArray(objeto))
-            return objeto;
-        if (objeto.valor instanceof estruturas_1.ObjetoPadrao)
-            return objeto.valor.paraTexto();
-        if (typeof objeto === 'object')
-            return JSON.stringify(objeto);
-        return objeto.toString();
+        return valores;
+    }
+    /* istanbul ignore next */
+    visitarExpressaoSuper(_expressao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarExpressaoFimPara(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarDeclaracaoTente(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    /* istanbul ignore next */
+    visitarDeclaracaoImportar(_declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    // ── Motor de execução ────────────────────────────────────────────────────────
+    async avaliar(expressao) {
+        return await expressao.aceitar(this);
+    }
+    procurarVariavel(simbolo) {
+        return this.pilhaEscoposExecucao.obterValorVariavel(simbolo);
     }
-    /**
-     * Efetivamente executa uma declaração.
-     * @param declaracao A declaração a ser executada.
-     * @param mostrarResultado Se resultado deve ser mostrado ou não. Normalmente usado
-     *                         pelo modo LAIR.
-     */
     async executar(declaracao, mostrarResultado = false) {
         const resultado = await declaracao.aceitar(this);
-        if (mostrarResultado) {
+        if (mostrarResultado)
             this.funcaoDeRetorno(this.paraTexto(resultado));
-        }
         if (resultado || typeof resultado === 'boolean') {
             this.resultadoInterpretador.push(this.paraTexto(resultado));
         }
         return resultado;
     }
-    /**
-     * Executa o último escopo empilhado no topo na pilha de escopos do interpretador.
-     * Esse método pega exceções, mas apenas as devolve.
-     *
-     * O tratamento das exceções é feito de acordo com o bloco chamador.
-     * Por exemplo, em `tente ... pegue ... finalmente`, a exceção é capturada e tratada.
-     * Em outros blocos, pode ser desejável ter o erro em tela.
-     * @param manterAmbiente Se verdadeiro, ambiente do topo da pilha de escopo é copiado para o ambiente imediatamente abaixo.
-     * @returns O resultado da execução do escopo, se houver.
-     */
     async executarUltimoEscopo(manterAmbiente = false) {
         const ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
         try {
@@ -560,10 +662,7 @@ class InterpretadorPortugolIpt {
         if (chamavel instanceof estruturas_1.FuncaoPadrao) {
             return chamavel.chamar(this, argumentos, null);
         }
-        const argumentosFormatados = argumentos.map((valor) => ({
-            nome: null,
-            valor,
-        }));
+        const argumentosFormatados = argumentos.map((valor) => ({ nome: null, valor }));
         return chamavel.chamar(this, argumentosFormatados, null);
     }
     async interpretar(declaracoes, manterAmbiente) {