@designliquido/delegua 1.14.0 → 1.15.1

package/umd/delegua.js

@@ -762,7 +762,10 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 switch (condicao.constructor) {
                     case construtos_1.Literal:
                         const condicaoLiteral = condicao;
-                        if (condicaoLiteral.tipo !== tipo) {
+                        const tiposNumericos = ['inteiro', 'número', 'real'];
+                        const ambosSaoNumericos = tiposNumericos.includes(condicaoLiteral.tipo) &&
+                            tiposNumericos.includes(tipo);
+                        if (condicaoLiteral.tipo !== tipo && !ambosSaoNumericos) {
                             this.erro({
                                 lexema: condicaoLiteral.valor,
                                 tipo: condicaoLiteral.tipo,
@@ -881,7 +884,14 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
             this.verificarOperadorBinario(binario.direita);
         }
         const operadoresMatematicos = ['ADICAO', 'SUBTRACAO', 'MULTIPLICACAO', 'DIVISAO', 'MODULO'];
-        const operadoresComparacao = ['MAIOR', 'MAIOR_IGUAL', 'MENOR', 'MENOR_IGUAL', 'IGUAL', 'DIFERENTE'];
+        const operadoresComparacao = [
+            'MAIOR',
+            'MAIOR_IGUAL',
+            'MENOR',
+            'MENOR_IGUAL',
+            'IGUAL',
+            'DIFERENTE',
+        ];
         if (operadoresMatematicos.includes(binario.operador.tipo)) {
             this.verificarTiposOperandos(binario);
         }
@@ -2679,6 +2689,16 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         if (entidadeChamada.constructor === construtos_1.Variavel) {
             const entidadeChamadaResolvidaVariavel = entidadeChamada;
+            const informacoesFuncaoBibliotecaGlobal = this.pilhaEscopos.obterBibliotecaGlobal(entidadeChamadaResolvidaVariavel.simbolo.lexema);
+            if (informacoesFuncaoBibliotecaGlobal &&
+                Array.isArray(informacoesFuncaoBibliotecaGlobal.subElementos) &&
+                informacoesFuncaoBibliotecaGlobal.subElementos.length > 0) {
+                const erros = this.validarArgumentosEntidadeChamada(informacoesFuncaoBibliotecaGlobal.subElementos, argumentos);
+                if (erros.length > 0) {
+                    throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamadaResolvidaVariavel.simbolo, `Erros ao resolver argumentos de chamada a ${entidadeChamadaResolvidaVariavel.simbolo.lexema}: \n${erros.reduce((mensagem, erro) => (mensagem += `${erro}\n`), '')}`);
+                }
+                return entidadeChamadaResolvidaVariavel;
+            }
             if (tipoPrimitiva === 'qualquer') {
                 // Provavelmente uma chamada a alguma função da biblioteca global.
                 // Até então, é sempre do tipo `InformacaoElementoSintatico`.
@@ -6373,12 +6393,8 @@ class AvaliadorSintaticoPitugues {
         }
         else {
             // Bloco de múltiplas linhas baseado em indentação
-            let espacosAtual = this
-                .localizacoes[simboloAtual.linha]
-                .espacosIndentacao;
-            const espacosAnterior = this
-                .localizacoes[simboloAnterior.linha]
-                .espacosIndentacao;
+            let espacosAtual = this.localizacoes[simboloAtual.linha].espacosIndentacao;
+            const espacosAnterior = this.localizacoes[simboloAnterior.linha].espacosIndentacao;
             if (espacosAtual <= espacosAnterior) {
                 throw this.erro(simboloAtual, `Indentação inconsistente na linha ${simboloAtual.linha}. ` +
                     `Esperado: >= ${espacosAnterior}. ` +
@@ -6392,9 +6408,7 @@ class AvaliadorSintaticoPitugues {
                     declaracoes = declaracoes.concat(retorno);
                 simboloAtual = this.simboloAtual();
                 if (simboloAtual) {
-                    espacosAtual = this
-                        .localizacoes[simboloAtual.linha]
-                        .espacosIndentacao;
+                    espacosAtual = this.localizacoes[simboloAtual.linha].espacosIndentacao;
                 }
             }
         }
@@ -6540,10 +6554,20 @@ class AvaliadorSintaticoPitugues {
     }
     async declaracaoSe() {
         const condicao = await this.expressao();
-        const caminhoEntao = (await this.resolverDeclaracao());
+        this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após condição do 'se'.");
+        const simboloColonEntao = this.simboloAnterior();
+        const caminhoEntao = new declaracoes_1.Bloco(simboloColonEntao.hashArquivo, Number(simboloColonEntao.linha), await this.blocoEscopo());
         let caminhoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SENAO, pitugues_2.default.SENÃO)) {
-            caminhoSenao = await this.resolverDeclaracao();
+            if (this.verificarTipoSimboloAtual(pitugues_2.default.SE)) {
+                // 'senao se' - encadeamento de condicionais, sem dois-pontos
+                caminhoSenao = await this.resolverDeclaracao();
+            }
+            else {
+                this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após 'senao'.");
+                const simboloColonSenao = this.simboloAnterior();
+                caminhoSenao = new declaracoes_1.Bloco(simboloColonSenao.hashArquivo, Number(simboloColonSenao.linha), await this.blocoEscopo());
+            }
         }
         return new declaracoes_1.Se(condicao, caminhoEntao, [], caminhoSenao);
     }
@@ -7386,6 +7410,7 @@ const browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime
 const construtos_1 = require("../../construtos");
 const declaracoes_1 = require("../../declaracoes");
 const avaliador_sintatico_base_1 = require("../avaliador-sintatico-base");
+const erro_avaliador_sintatico_1 = require("../erro-avaliador-sintatico");
 const inferenciador_1 = require("../../inferenciador");
 const pilha_escopos_1 = require("../pilha-escopos");
 const informacao_escopo_1 = require("../informacao-escopo");
@@ -7470,6 +7495,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         return false;
     }
     async primario() {
+        var _a;
         const simboloAtual = this.simbolos[this.atual];
         let valores = [];
         switch (simboloAtual.tipo) {
@@ -7491,10 +7517,16 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
                 }
                 let indice = 1;
                 do {
-                    let chave = String(indice);
-                    if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.COLCHETE_ESQUERDO)) {
-                        // Lógica para índice nomeado
-                        // TODO: Terminar
+                    let chave;
+                    if (this.verificarTipoSimboloAtual(prisma_1.default.IDENTIFICADOR) &&
+                        ((_a = this.simbolos[this.atual + 1]) === null || _a === void 0 ? void 0 : _a.tipo) === prisma_1.default.IGUAL) {
+                        // Chave nomeada: {nome = "João"}
+                        const chaveIdentificador = this.avancarEDevolverAnterior();
+                        this.avancarEDevolverAnterior(); // consume IGUAL
+                        chave = new construtos_1.Literal(this.hashArquivo, simboloAtual.linha, chaveIdentificador.lexema);
+                    }
+                    else {
+                        chave = new construtos_1.Literal(this.hashArquivo, simboloAtual.linha, String(indice));
                     }
                     const valor = await this.ou();
                     chaves.push(chave);
@@ -7554,8 +7586,12 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         }
         throw this.erro(this.simbolos[this.atual], 'Esperado expressão.');
     }
-    expressaoImportar() {
-        throw new Error('Método não implementado.');
+    async expressaoImportar() {
+        this.avancarEDevolverAnterior();
+        this.consumir(prisma_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
+        const caminho = await this.expressao();
+        this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
+        return new construtos_1.ImportarComoConstruto(caminho);
     }
     /**
      * Construto para texto multilinhas.
@@ -7623,7 +7659,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         return expressao;
     }
     async unario() {
-        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.NEGACAO, prisma_1.default.SUBTRACAO, prisma_1.default.BIT_NOT)) {
+        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.NEGACAO, prisma_1.default.SUBTRACAO, prisma_1.default.BIT_NOT, prisma_1.default.NAO, prisma_1.default.COMPRIMENTO)) {
             const operador = this.simboloAnterior();
             const direito = await this.unario();
             return new construtos_1.Unario(this.hashArquivo, operador, direito);
@@ -7657,8 +7693,17 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         }
         return expressao;
     }
-    async bitShift() {
+    async concatenacao() {
         let expressao = await this.adicaoOuSubtracao();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.CONCATENACAO)) {
+            const operador = this.simboloAnterior();
+            const direito = await this.adicaoOuSubtracao();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    async bitShift() {
+        let expressao = await this.concatenacao();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.MENOR_MENOR, prisma_1.default.MAIOR_MAIOR)) {
             const operador = this.simboloAnterior();
             const direito = await this.adicaoOuSubtracao();
@@ -7729,8 +7774,19 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         }
         return expressao;
     }
+    async ternario() {
+        let expressaoOuCondicao = await this.ou();
+        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.INTERROGACAO)) {
+            const operador = this.simboloAnterior();
+            const caminhoEntao = await this.e();
+            this.consumir(prisma_1.default.OU, "Esperado palavra reservada 'ou' após caminho positivo em operador ternário.");
+            const caminhoSenao = await this.ternario();
+            expressaoOuCondicao = new construtos_1.SeTernario(this.hashArquivo, expressaoOuCondicao, caminhoEntao, operador, caminhoSenao);
+        }
+        return expressaoOuCondicao;
+    }
     async atribuir() {
-        const expressao = await this.ou();
+        const expressao = await this.ternario();
         if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.IGUAL) ||
             this.verificarSeSimboloAtualEIgualA(prisma_1.default.MAIS_IGUAL)) {
             const igual = this.simboloAnterior();
@@ -7782,7 +7838,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         }
         this.consumir(prisma_1.default.FIM, "Esperado 'fim' após o bloco.");
         this.pilhaEscopos.removerUltimo();
-        return declaracoes;
+        return declaracoes.filter((d) => d);
     }
     async declaracaoDeLocal() {
         const identificador = this.consumir(prisma_1.default.IDENTIFICADOR, 'Esperado nome de variável.');
@@ -7807,6 +7863,65 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             this.blocos -= 1;
         }
     }
+    async declaracaoEscolha() {
+        try {
+            this.blocos += 1;
+            const condicao = await this.expressao();
+            const caminhos = [];
+            let caminhoPadrao = null;
+            while (!this.verificarTipoSimboloAtual(prisma_1.default.FIM) && !this.estaNoFinal()) {
+                if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.CASO)) {
+                    const caminhoCondicoes = [await this.expressao()];
+                    while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.CASO)) {
+                        caminhoCondicoes.push(await this.expressao());
+                    }
+                    this.consumir(prisma_1.default.ENTAO, "Esperado palavra reservada 'entao' ou 'então' após valor do 'caso'.");
+                    const declaracoes = [];
+                    while (!this.estaNoFinal() &&
+                        ![
+                            prisma_1.default.CASO,
+                            prisma_1.default.PADRAO,
+                            prisma_1.default.FIM,
+                        ].includes(this.simbolos[this.atual].tipo)) {
+                        declaracoes.push(await this.resolverDeclaracaoForaDeBloco());
+                    }
+                    caminhos.push({
+                        condicoes: caminhoCondicoes,
+                        declaracoes: declaracoes.filter((d) => d),
+                    });
+                }
+                else if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.PADRAO)) {
+                    if (caminhoPadrao !== null) {
+                        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(this.simbolos[this.atual], "Você só pode ter um 'padrao' em cada declaração de 'escolha'.");
+                        this.erros.push(excecao);
+                        throw excecao;
+                    }
+                    this.consumir(prisma_1.default.ENTAO, "Esperado palavra reservada 'entao' ou 'então' após declaração do 'padrao'.");
+                    const declaracoes = [];
+                    while (!this.estaNoFinal() &&
+                        ![
+                            prisma_1.default.CASO,
+                            prisma_1.default.PADRAO,
+                            prisma_1.default.FIM,
+                        ].includes(this.simbolos[this.atual].tipo)) {
+                        declaracoes.push(await this.resolverDeclaracaoForaDeBloco());
+                    }
+                    caminhoPadrao = {
+                        condicoes: [],
+                        declaracoes: declaracoes.filter((d) => d),
+                    };
+                }
+                else {
+                    throw this.erro(this.simbolos[this.atual], "Esperado 'caso', 'padrao' ou 'fim' em declaração 'escolha'.");
+                }
+            }
+            this.consumir(prisma_1.default.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'escolha'.");
+            return new declaracoes_1.Escolha(condicao, caminhos, caminhoPadrao);
+        }
+        finally {
+            this.blocos -= 1;
+        }
+    }
     async declaracaoSe() {
         const simboloSe = this.simbolos[this.atual];
         const condicao = await this.expressao();
@@ -7817,17 +7932,57 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         } while (!this.estaNoFinal() &&
             ![prisma_1.default.SENAO, prisma_1.default.SENÃO, prisma_1.default.FIM].includes(this.simbolos[this.atual].tipo));
         let caminhoSenao = null;
+        let fimConsumidoNoCaminhoSenao = false;
         if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.SENAO, prisma_1.default.SENÃO)) {
             const simboloSenao = this.simbolos[this.atual - 1];
-            const declaracoesSenao = [];
-            do {
-                declaracoesSenao.push(await this.resolverDeclaracaoForaDeBloco());
-            } while (![prisma_1.default.FIM].includes(this.simbolos[this.atual].tipo));
-            caminhoSenao = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSenao.linha), declaracoesSenao.filter((d) => d));
+            if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.SE)) {
+                caminhoSenao = await this.declaracaoSe();
+                fimConsumidoNoCaminhoSenao = true;
+            }
+            else {
+                const declaracoesSenao = [];
+                do {
+                    declaracoesSenao.push(await this.resolverDeclaracaoForaDeBloco());
+                } while (![prisma_1.default.FIM].includes(this.simbolos[this.atual].tipo));
+                caminhoSenao = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSenao.linha), declaracoesSenao.filter((d) => d));
+            }
+        }
+        if (!fimConsumidoNoCaminhoSenao) {
+            this.consumir(prisma_1.default.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'se'.");
         }
-        this.consumir(prisma_1.default.FIM, "Esperado palavra-chave 'fimse' para fechamento de declaração 'se'.");
         return new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSe.linha), declaracoes.filter((d) => d)), [], caminhoSenao);
     }
+    async declaracaoTente() {
+        const simboloTente = this.simboloAnterior();
+        const blocoTente = [];
+        while (!this.estaNoFinal() &&
+            ![
+                prisma_1.default.PEGUE,
+                prisma_1.default.FINALMENTE,
+                prisma_1.default.FIM,
+            ].includes(this.simbolos[this.atual].tipo)) {
+            blocoTente.push(await this.resolverDeclaracaoForaDeBloco());
+        }
+        let blocoPegue = null;
+        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.PEGUE)) {
+            const declaracoesPegue = [];
+            while (!this.estaNoFinal() &&
+                ![prisma_1.default.FINALMENTE, prisma_1.default.FIM].includes(this.simbolos[this.atual].tipo)) {
+                declaracoesPegue.push(await this.resolverDeclaracaoForaDeBloco());
+            }
+            blocoPegue = declaracoesPegue.filter((d) => d);
+        }
+        let blocoFinalmente = null;
+        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.FINALMENTE)) {
+            const declaracoesFinalmente = [];
+            while (!this.estaNoFinal() && !this.verificarTipoSimboloAtual(prisma_1.default.FIM)) {
+                declaracoesFinalmente.push(await this.resolverDeclaracaoForaDeBloco());
+            }
+            blocoFinalmente = declaracoesFinalmente.filter((d) => d);
+        }
+        this.consumir(prisma_1.default.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'tente'.");
+        return new declaracoes_1.Tente(simboloTente.hashArquivo, Number(simboloTente.linha), blocoTente.filter((d) => d), blocoPegue, null, blocoFinalmente);
+    }
     async declaracaoQuebre() {
         if (this.blocos < 1) {
             throw this.erro(this.simboloAnterior(), "'quebre' deve estar dentro de um laço de repetição.");
@@ -7911,11 +8066,15 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
                 return null;
             case prisma_1.default.ENTAO:
             case prisma_1.default.INICIO:
+            case prisma_1.default.FAZER:
                 const simboloInicioBloco = this.avancarEDevolverAnterior();
                 return new declaracoes_1.Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), await this.blocoEscopo());
             case prisma_1.default.ENQUANTO:
                 this.avancarEDevolverAnterior();
                 return await this.declaracaoEnquanto();
+            case prisma_1.default.ESCOLHA:
+                this.avancarEDevolverAnterior();
+                return await this.declaracaoEscolha();
             case prisma_1.default.IDENTIFICADOR:
                 const proximoSimbolo = this.simbolos[this.atual + 1];
                 if (proximoSimbolo && proximoSimbolo.tipo === prisma_1.default.IGUAL) {
@@ -7937,6 +8096,9 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             case prisma_1.default.RETORNE:
                 this.avancarEDevolverAnterior();
                 return await this.declaracaoRetorna();
+            case prisma_1.default.TENTE:
+                this.avancarEDevolverAnterior();
+                return await this.declaracaoTente();
             case prisma_1.default.LOCAL:
                 this.avancarEDevolverAnterior();
                 return await this.declaracaoDeLocal();
@@ -7979,20 +8141,40 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
                 console.log(inicializador.constructor.name);
         }
     }
+    async declaracaoParaCada(simboloPara) {
+        const variavelIteracao = this.consumir(prisma_1.default.IDENTIFICADOR, "Esperado identificador de variável após 'para cada'.");
+        this.consumir(prisma_1.default.EM, "Esperado palavra reservada 'em' após variável de iteração.");
+        const vetorOuDicionario = await this.expressao();
+        this.consumir(prisma_1.default.INICIO, `espera-se 'inicio' proximo a '${this.simbolos[this.atual].lexema}'.`);
+        this.pilhaEscopos.definirInformacoesVariavel(variavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(variavelIteracao.lexema, 'qualquer'));
+        const declaracoesBlocoParaCada = [];
+        while (!this.estaNoFinal() && !this.verificarTipoSimboloAtual(prisma_1.default.FIM)) {
+            declaracoesBlocoParaCada.push(await this.resolverDeclaracaoForaDeBloco());
+        }
+        this.consumir(prisma_1.default.FIM, "Esperado 'fim' após bloco do para cada.");
+        const corpo = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloPara.linha) + 1, declaracoesBlocoParaCada.filter((d) => d));
+        return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'qualquer'), vetorOuDicionario, corpo);
+    }
     async declaracaoPara() {
         try {
             this.blocos += 1;
             const simboloPara = this.avancarEDevolverAnterior();
+            if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.CADA)) {
+                return await this.declaracaoParaCada(simboloPara);
+            }
             const variavelIteracao = this.consumir(prisma_1.default.IDENTIFICADOR, "Esperado identificador de variável após 'para'.");
             this.consumir(prisma_1.default.IGUAL, `'=' or 'em' esperado próximo a '${this.simbolos[this.atual].lexema}'.`);
             const literalOuVariavelInicio = await this.adicaoOuSubtracao();
             this.consumir(prisma_1.default.VIRGULA, `Espera-se '=' próximo a '${this.simbolos[this.atual].lexema}'.`);
             const literalOuVariavelFim = await this.adicaoOuSubtracao();
             let operadorCondicao = new lexador_1.Simbolo(prisma_1.default.MENOR_IGUAL, '<=', null, Number(simboloPara.linha), this.hashArquivo);
-            let operadorCondicaoIncremento = new lexador_1.Simbolo(prisma_1.default.MENOR, '<', null, Number(simboloPara.linha), this.hashArquivo);
             let passo = new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1);
-            const resolverIncrementoEmExecucao = false; // Mudar caso seja necessário.
-            this.consumir(prisma_1.default.INICIO, `espera-se 'inicio' proximo a '${this.simbolos[this.atual].lexema}'.`);
+            if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.VIRGULA)) {
+                passo = await this.adicaoOuSubtracao();
+            }
+            if (!this.verificarSeSimboloAtualEIgualA(prisma_1.default.INICIO, prisma_1.default.FAZER)) {
+                throw this.erro(this.simbolos[this.atual], `espera-se 'inicio' ou 'fazer' proximo a '${this.simbolos[this.atual].lexema}'.`);
+            }
             // Aqui já é seguro inicializar a variável.
             this.pilhaEscopos.definirInformacoesVariavel(variavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(variavelIteracao.lexema, 'inteiro'));
             const declaracoesBlocoPara = [];
@@ -8004,14 +8186,12 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             this.avancarEDevolverAnterior(); // fim
             const corpo = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloPara.linha) + 1, declaracoesBlocoPara.filter((d) => d));
             const para = new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), 
-            // Inicialização.
-            new declaracoes_1.Expressao(new construtos_1.Atribuir(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), literalOuVariavelInicio)), 
+            // Inicialização: declara a variável de iteração.
+            new declaracoes_1.Var(variavelIteracao, literalOuVariavelInicio, 'inteiro'), 
             // Condição.
             new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), operadorCondicao, literalOuVariavelFim), 
-            // Incremento, feito em construto especial `FimPara`.
-            new construtos_1.FimPara(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), operadorCondicaoIncremento, literalOuVariavelFim), new declaracoes_1.Expressao(new construtos_1.Atribuir(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), new lexador_1.Simbolo(prisma_1.default.ADICAO, '+', null, Number(simboloPara.linha), this.hashArquivo), passo)))), corpo);
-            para.blocoPosExecucao = corpo;
-            para.resolverIncrementoEmExecucao = resolverIncrementoEmExecucao;
+            // Incremento simples.
+            new construtos_1.Atribuir(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), new lexador_1.Simbolo(prisma_1.default.ADICAO, '+', null, Number(simboloPara.linha), this.hashArquivo), passo)), corpo);
             return para;
         }
         finally {
@@ -8036,6 +8216,48 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             return null;
         }
     }
+    async metodoClassePrisma(construtor) {
+        const simbolo = construtor
+            ? new lexador_1.Simbolo(prisma_1.default.CONSTRUTOR, 'construtor', null, Number(this.simboloAnterior().linha), this.hashArquivo)
+            : this.consumir(prisma_1.default.IDENTIFICADOR, 'Esperado nome do método.');
+        this.consumir(prisma_1.default.PARENTESE_ESQUERDO, "Esperado '(' após nome do método.");
+        let parametros = [];
+        if (!this.verificarTipoSimboloAtual(prisma_1.default.PARENTESE_DIREITO)) {
+            parametros = await this.logicaComumParametros();
+        }
+        this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        this.consumir(prisma_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do corpo do método.");
+        const declaracoesCorpo = [];
+        while (!this.estaNoFinal() && !this.verificarTipoSimboloAtual(prisma_1.default.CHAVE_DIREITA)) {
+            declaracoesCorpo.push(await this.resolverDeclaracaoForaDeBloco());
+        }
+        this.consumir(prisma_1.default.CHAVE_DIREITA, "Esperado '}' após o corpo do método.");
+        const corpoDaFuncao = new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simbolo.linha), parametros, declaracoesCorpo.filter((d) => d), 'qualquer', false);
+        const tipoDaFuncao = `função<${corpoDaFuncao.tipo}>`;
+        return new declaracoes_1.FuncaoDeclaracao(simbolo, corpoDaFuncao, tipoDaFuncao);
+    }
+    propriedadesDeclaradasEmMetodo(metodo) {
+        const propriedades = [];
+        const nomesPropriedades = new Set();
+        for (const declaracao of metodo.funcao.corpo) {
+            if (!(declaracao instanceof declaracoes_1.Expressao)) {
+                continue;
+            }
+            if (!(declaracao.expressao instanceof construtos_1.DefinirValor)) {
+                continue;
+            }
+            if (!(declaracao.expressao.objeto instanceof construtos_1.Isto)) {
+                continue;
+            }
+            const nomePropriedade = declaracao.expressao.nome.lexema;
+            if (nomesPropriedades.has(nomePropriedade)) {
+                continue;
+            }
+            nomesPropriedades.add(nomePropriedade);
+            propriedades.push(new declaracoes_1.PropriedadeClasse(declaracao.expressao.nome, 'qualquer'));
+        }
+        return propriedades;
+    }
     async declaracaoDeClasse() {
         const simbolo = this.consumir(prisma_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
         let superClasse = null;
@@ -8051,47 +8273,71 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             (this.verificarTipoSimboloAtual(prisma_1.default.CONSTRUTOR) ||
                 this.verificarTipoSimboloAtual(prisma_1.default.FUNCAO) ||
                 this.verificarTipoSimboloAtual(prisma_1.default.FUNÇÃO))) {
-            const ehConstrutor = this.verificarSeSimboloAtualEIgualA(prisma_1.default.CONSTRUTOR);
-            metodos.push(await this.funcao('método'));
+            if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.CONSTRUTOR)) {
+                metodos.push(await this.metodoClassePrisma(true));
+                continue;
+            }
+            this.verificarSeSimboloAtualEIgualA(prisma_1.default.FUNCAO, prisma_1.default.FUNÇÃO);
+            metodos.push(await this.metodoClassePrisma(false));
         }
         this.consumir(prisma_1.default.CHAVE_DIREITA, "Esperado '}' após métodos da classe.");
+        const propriedades = [];
+        const nomesPropriedades = new Set();
+        for (const metodo of metodos) {
+            const propriedadesDoMetodo = this.propriedadesDeclaradasEmMetodo(metodo);
+            for (const propriedade of propriedadesDoMetodo) {
+                if (nomesPropriedades.has(propriedade.nome.lexema)) {
+                    continue;
+                }
+                nomesPropriedades.add(propriedade.nome.lexema);
+                propriedades.push(propriedade);
+            }
+        }
         this.superclasseAtual = undefined;
-        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse ? [superClasse] : [], metodos);
+        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse ? [superClasse] : [], metodos, propriedades);
         this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
         return definicaoClasse;
     }
     inicializarPilhaEscopos() {
         this.pilhaEscopos = new pilha_escopos_1.PilhaEscopos();
         this.pilhaEscopos.empilhar(new informacao_escopo_1.InformacaoEscopo());
-        // TODO: verificar quais são as funções nativas básicas de Prisma
-        /* this.pilhaEscopos.definirInformacoesVariavel(
-            'aleatorio',
-            new InformacaoElementoSintatico('aleatorio', 'número')
-        );
-        this.pilhaEscopos.definirInformacoesVariavel(
-            'inteiro',
-            new InformacaoElementoSintatico('inteiro', 'inteiro', true, [
-                new InformacaoElementoSintatico('valor', 'qualquer'),
-            ])
-        );
-        this.pilhaEscopos.definirInformacoesVariavel(
-            'numero',
-            new InformacaoElementoSintatico('número', 'número', true, [
-                new InformacaoElementoSintatico('valorParaConverter', 'qualquer'),
-            ])
-        );
-        this.pilhaEscopos.definirInformacoesVariavel(
-            'texto',
-            new InformacaoElementoSintatico('texto', 'texto', true, [
-                new InformacaoElementoSintatico('valorParaConverter', 'qualquer'),
-            ])
-        );
-        this.pilhaEscopos.definirInformacoesVariavel(
-            'tamanho',
-            new InformacaoElementoSintatico('tamanho', 'inteiro', true, [
-                new InformacaoElementoSintatico('objeto', 'qualquer'),
-            ])
-        ); */
+        // Registrar funções nativas (built-ins) do Prisma no escopo do parser
+        // para evitar erros de variável não definida durante análise semântica
+        this.pilhaEscopos.definirInformacoesVariavel('tipo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tipo', 'função', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valor', 'qualquer'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('poe', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('poe', 'função', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valores', 'qualquer'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('tamanho', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tamanho', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('objeto', 'qualquer'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('pares', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('pares', 'tabela', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tabela', 'tabela'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('ipares', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('ipares', 'tabela', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tabela', 'tabela'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('convnumero', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('convnumero', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valor', 'qualquer'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('convstring', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('convstring', 'texto', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valor', 'qualquer'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('aleatorio', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('aleatorio', 'função', true, []));
+        this.pilhaEscopos.definirInformacoesVariavel('aleatorio_entre', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('aleatorio_entre', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('minimo', 'número'),
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('maximo', 'número'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('coletelixo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('coletelixo', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('acao', 'texto'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('piso', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('piso', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('n', 'número'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('teto', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('teto', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('n', 'número'),
+        ]));
     }
     async analisar(retornoLexador, hashArquivo) {
         const inicioAnalise = (0, browser_process_hrtime_1.default)();
@@ -8124,7 +8370,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
 }
 exports.AvaliadorSintaticoPrisma = AvaliadorSintaticoPrisma;
 
-},{"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../declaracoes":110,"../../inferenciador":137,"../../informacao-elemento-sintatico":138,"../../lexador":207,"../../tipos-de-simbolos/prisma":228,"../avaliador-sintatico-base":9,"../comum":11,"../informacao-escopo":22,"../pilha-escopos":26,"browser-process-hrtime":415}],16:[function(require,module,exports){
+},{"../../bibliotecas/primitivas-dicionario":29,"../../bibliotecas/primitivas-numero":30,"../../bibliotecas/primitivas-texto":31,"../../bibliotecas/primitivas-vetor":32,"../../construtos":62,"../../declaracoes":110,"../../inferenciador":137,"../../informacao-elemento-sintatico":138,"../../lexador":207,"../../tipos-de-simbolos/prisma":228,"../avaliador-sintatico-base":9,"../comum":11,"../erro-avaliador-sintatico":20,"../informacao-escopo":22,"../pilha-escopos":26,"browser-process-hrtime":415}],16:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -8313,6 +8559,16 @@ class AvaliadorSintaticoTenda extends avaliador_sintatico_base_1.AvaliadorSintat
                     this.avancarEDevolverAnterior();
                     return new construtos_1.ExpressaoRegular(this.hashArquivo, simboloAtual, valor);
                 }
+            case tenda_1.default.BIBLIOTECA_GLOBAL: {
+                const simboloBiblioteca = this.avancarEDevolverAnterior();
+                return new construtos_1.Variavel(this.hashArquivo, simboloBiblioteca, 'qualquer');
+            }
+            case tenda_1.default.INFINITO:
+                this.avancarEDevolverAnterior();
+                return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), Infinity, 'número');
+            case tenda_1.default.NAN:
+                this.avancarEDevolverAnterior();
+                return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), NaN, 'número');
             case tenda_1.default.FALSO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), false, 'lógico');
@@ -8371,6 +8627,7 @@ class AvaliadorSintaticoTenda extends avaliador_sintatico_base_1.AvaliadorSintat
         throw this.erro(this.simbolos[this.atual], 'Esperado expressão.');
     }
     async chamar() {
+        var _a;
         let expressao = await this.primario();
         while (true) {
             let tipoPrimitiva = undefined;
@@ -8378,7 +8635,21 @@ class AvaliadorSintaticoTenda extends avaliador_sintatico_base_1.AvaliadorSintat
                 expressao = await this.finalizarChamada(expressao, tipoPrimitiva);
             }
             else if (this.verificarSeSimboloAtualEIgualA(tenda_1.default.PONTO)) {
-                const nome = this.consumir(tenda_1.default.IDENTIFICADOR, "Esperado nome de método ou propriedade após '.'.");
+                // Alguns tokens de biblioteca global são palavras reservadas (ex: `exiba`, `leia`, `entrada`),
+                // mas precisam ser aceitos como nomes de métodos após o ponto.
+                const tiposAceitosComoNomeDeMetodo = [
+                    tenda_1.default.IDENTIFICADOR,
+                    tenda_1.default.EXIBA,
+                    tenda_1.default.LEIA,
+                    tenda_1.default.ENTRADA,
+                ];
+                let nome;
+                if (tiposAceitosComoNomeDeMetodo.includes((_a = this.simbolos[this.atual]) === null || _a === void 0 ? void 0 : _a.tipo)) {
+                    nome = this.avancarEDevolverAnterior();
+                }
+                else {
+                    nome = this.consumir(tenda_1.default.IDENTIFICADOR, "Esperado nome de método ou propriedade após '.'.");
+                }
                 tipoPrimitiva = expressao.tipo;
                 expressao = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, expressao, nome);
             }
@@ -8919,7 +9190,9 @@ class AvaliadorSintaticoTenda extends avaliador_sintatico_base_1.AvaliadorSintat
                         if (this.primitivasConhecidas.hasOwnProperty(entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema)) {
                             return this.primitivasConhecidas[entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema].tipo;
                         }
-                        throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamadaAcessoMetodoOuPropriedade.simbolo, `Primitiva '${entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema}' não existe.`);
+                        // Para métodos de namespaces da biblioteca global (Lista, Matemática, etc.),
+                        // o tipo não é conhecido estaticamente. Retorna 'qualquer'.
+                        return 'qualquer';
                     case construtos_1.AcessoPropriedade:
                         const entidadeChamadaAcessoPropriedade = entidadeChamadaChamada;
                         return entidadeChamadaAcessoPropriedade.tipoRetornoPropriedade;
@@ -9067,6 +9340,10 @@ class AvaliadorSintaticoTenda extends avaliador_sintatico_base_1.AvaliadorSintat
     inicializarPilhaEscopos() {
         this.pilhaEscopos = new pilha_escopos_1.PilhaEscopos();
         this.pilhaEscopos.empilhar(new informacao_escopo_1.InformacaoEscopo());
+        // Registrar namespaces da biblioteca global de Tenda.
+        for (const nomeBiblioteca of ['Data', 'Lista', 'Matemática', 'Saída', 'Texto']) {
+            this.pilhaEscopos.definirInformacoesVariavel(nomeBiblioteca, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeBiblioteca, 'qualquer'));
+        }
         // TODO: Escrever algum tipo de validação aqui.
         for (const tipos of Object.values(this.tiposDeFerramentasExternas)) {
             for (const [nomeTipo, tipo] of Object.entries(tipos)) {
@@ -10065,15 +10342,13 @@ async function aleatorio(interpretador) {
  * @returns {Promise<number>} Um número real entre os valores máximo e mínimo especificados.
  */
 async function aleatorioEntre(interpretador, minimo, maximo) {
-    if (arguments.length <= 0) {
+    if (arguments.length <= 1) {
         return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
             linha: interpretador.linhaDeclaracaoAtual,
         }, 'A função recebe ao menos um parâmetro.'));
     }
-    const valorMinimo = minimo.hasOwnProperty('valor')
-        ? minimo.valor
-        : minimo;
+    const valorMinimo = interpretador.resolverValor(minimo);
     if (arguments.length === 2) {
         if (typeof valorMinimo !== 'number') {
             return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
@@ -10089,9 +10364,7 @@ async function aleatorioEntre(interpretador, minimo, maximo) {
             linha: interpretador.linhaDeclaracaoAtual,
         }, 'A quantidade de parâmetros máxima para esta função é 2.'));
     }
-    const valorMaximo = maximo.hasOwnProperty('valor')
-        ? maximo.valor
-        : maximo;
+    const valorMaximo = interpretador.resolverValor(maximo);
     if (typeof valorMinimo !== 'number' || typeof valorMaximo !== 'number') {
         return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
@@ -21087,6 +21360,27 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
     pontoInicializacaoBibliotecasGlobais() {
         (0, comum_1.carregarBibliotecasGlobais)(this.pilhaEscoposExecucao);
     }
+    async avaliarArgumentosEscreva(argumentos) {
+        if (this.constructor !== Interpretador) {
+            return await super.avaliarArgumentosEscreva(argumentos);
+        }
+        let formatoTexto = '';
+        for (const argumento of argumentos) {
+            let resultadoAvaliacao = await this.avaliar(argumento);
+            if (resultadoAvaliacao &&
+                resultadoAvaliacao.hasOwnProperty &&
+                resultadoAvaliacao.hasOwnProperty('valorRetornado')) {
+                resultadoAvaliacao = resultadoAvaliacao.valorRetornado;
+            }
+            if (argumento instanceof construtos_1.Atribuir || argumento instanceof construtos_1.AtribuicaoPorIndice) {
+                formatoTexto += `${argumento.paraTexto()} `;
+                continue;
+            }
+            const valor = this.resolverValor(resultadoAvaliacao);
+            formatoTexto += `${this.paraTexto(valor)} `;
+        }
+        return formatoTexto.trimEnd();
+    }
     resolverReferenciaMontao(referenciaMontao) {
         const valorMontao = this.montao.obterReferencia(this.hashArquivoDeclaracaoAtual, this.linhaDeclaracaoAtual, referenciaMontao.endereco);
         return valorMontao;
@@ -21248,7 +21542,9 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 const nomeDecorador = decorador.nome.slice(1);
                 const variavelDecoradora = this.pilhaEscoposExecucao.obterVariavelPorNome(nomeDecorador);
                 const funcaoDecoradora = variavelDecoradora.valor;
-                const resultado = await funcaoDecoradora.chamar(this, [{ nome: null, valor: funcao }]);
+                const resultado = await funcaoDecoradora.chamar(this, [
+                    { nome: null, valor: funcao },
+                ]);
                 funcao = this.resolverValorRecursivo(resultado);
             }
         }
@@ -22363,6 +22659,7 @@ const lexador_1 = require("../lexador");
 const inferenciador_1 = require("../inferenciador");
 const delegua_1 = __importDefault(require("../tipos-de-dados/delegua"));
 const tiposNumericos = ['inteiro', 'número', 'numero', 'real', 'longo'];
+const tiposLogicos = ['logico', 'lógico'];
 class PilhaEscoposExecucao {
     constructor() {
         this.pilha = [];
@@ -22394,6 +22691,8 @@ class PilhaEscoposExecucao {
             return true;
         if (tiposNumericos.includes(tipoVariavel) && tiposNumericos.includes(tipoValor))
             return true;
+        if (tiposLogicos.includes(tipoVariavel) && tiposLogicos.includes(tipoValor))
+            return true;
         return false;
     }
     converterValor(tipo, valor) {
@@ -22808,6 +23107,24 @@ class LexadorCalango {
         const textoCompleto = this.codigo[this.linha].substring(this.inicioSimbolo + 1, this.atual);
         this.simbolos.push(new simbolo_1.Simbolo(calango_2.default.TEXTO, textoCompleto, textoCompleto, linhaPrimeiroCaracter + 1, this.hashArquivo));
     }
+    analisarCaracter() {
+        const linhaPrimeiroCaracter = this.linha;
+        // Restringe leitura à linha atual (como analisarNumero), evitando
+        // que avancar() mude this.linha e corrompa o cálculo do substring.
+        while (this.simboloAtual() !== "'" && this.linha === linhaPrimeiroCaracter && !this.eFinalDoCodigo()) {
+            this.avancar();
+        }
+        if (this.linha !== linhaPrimeiroCaracter || this.eFinalDoCodigo()) {
+            this.erros.push({
+                linha: linhaPrimeiroCaracter + 1,
+                caractere: this.simboloAnterior(),
+                mensagem: 'Caractere não finalizado.',
+            });
+            return;
+        }
+        const valorCaracter = this.codigo[linhaPrimeiroCaracter].substring(this.inicioSimbolo + 1, this.atual);
+        this.simbolos.push(new simbolo_1.Simbolo(calango_2.default.LITERAL_CARACTER, valorCaracter, valorCaracter, linhaPrimeiroCaracter + 1, this.hashArquivo));
+    }
     analisarNumero() {
         const linhaPrimeiroDigito = this.linha;
         while (this.eDigito(this.simboloAtual()) && this.linha === linhaPrimeiroDigito) {
@@ -22870,6 +23187,23 @@ class LexadorCalango {
                 this.analisarTexto('"');
                 this.avancar();
                 break;
+            case "'":
+                this.avancar();
+                this.analisarCaracter();
+                this.avancar();
+                break;
+            case ':':
+                this.adicionarSimbolo(calango_2.default.DOIS_PONTOS);
+                this.avancar();
+                break;
+            case '[':
+                this.adicionarSimbolo(calango_2.default.COLCHETE_ESQUERDO);
+                this.avancar();
+                break;
+            case ']':
+                this.adicionarSimbolo(calango_2.default.COLCHETE_DIREITO);
+                this.avancar();
+                break;
             case '(':
                 this.adicionarSimbolo(calango_2.default.PARENTESE_ESQUERDO);
                 this.avancar();
@@ -22878,6 +23212,36 @@ class LexadorCalango {
                 this.adicionarSimbolo(calango_2.default.PARENTESE_DIREITO);
                 this.avancar();
                 break;
+            case ',':
+                this.adicionarSimbolo(calango_2.default.VIRGULA);
+                this.avancar();
+                break;
+            case '+':
+                this.adicionarSimbolo(calango_2.default.ADICAO);
+                this.avancar();
+                break;
+            case '-':
+                this.adicionarSimbolo(calango_2.default.SUBTRACAO);
+                this.avancar();
+                break;
+            case '*':
+                this.adicionarSimbolo(calango_2.default.MULTIPLICACAO);
+                this.avancar();
+                break;
+            case '/':
+                if (this.proximoSimbolo() === '/') {
+                    // Comentário de linha: consumir até ao fim da linha sem emitir símbolo.
+                    // Guardamos o número da linha para parar quando avancar() mudar para a próxima.
+                    const linhaComentario = this.linha;
+                    while (this.linha === linhaComentario && !this.eFinalDoCodigo()) {
+                        this.avancar();
+                    }
+                }
+                else {
+                    this.adicionarSimbolo(calango_2.default.DIVISAO);
+                    this.avancar();
+                }
+                break;
             case '=':
                 this.adicionarSimbolo(calango_2.default.IGUAL_ATRIBUICAO);
                 this.avancar();
@@ -22898,10 +23262,22 @@ class LexadorCalango {
                     this.adicionarSimbolo(calango_2.default.MENOR_IGUAL, '<=');
                     this.avancar();
                 }
+                else if (this.simboloAtual() === '>') {
+                    this.adicionarSimbolo(calango_2.default.DIFERENTE, '<>');
+                    this.avancar();
+                }
                 else {
                     this.adicionarSimbolo(calango_2.default.MENOR);
                 }
                 break;
+            case '%':
+                this.adicionarSimbolo(calango_2.default.MODULO);
+                this.avancar();
+                break;
+            case '^':
+                this.adicionarSimbolo(calango_2.default.EXPONENCIACAO);
+                this.avancar();
+                break;
             default:
                 if (this.eDigito(caractere))
                     this.analisarNumero();
@@ -23555,15 +23931,13 @@ class LexadorPitugues {
     }
     analisarNumero() {
         const linhaInicial = this.linha;
-        while (this.linha === linhaInicial &&
-            this.eDigito(this.simboloAtual()))
+        while (this.linha === linhaInicial && this.eDigito(this.simboloAtual()))
             this.avancar();
         const temPonto = this.simboloAtual() === '.';
         const proximoEhDigito = this.eDigito(this.proximoSimbolo());
         if (this.linha === linhaInicial && temPonto && proximoEhDigito) {
             this.avancar();
-            while (this.linha === linhaInicial &&
-                this.eDigito(this.simboloAtual()))
+            while (this.linha === linhaInicial && this.eDigito(this.simboloAtual()))
                 this.avancar();
         }
         let numeroCompleto;
@@ -24332,7 +24706,17 @@ class LexadorPrisma {
                 this.avancar();
                 break;
             case '.':
-                this.adicionarSimbolo(prisma_2.default.PONTO);
+                this.avancar();
+                if (this.simboloAtual() === '.') {
+                    this.avancar();
+                    this.adicionarSimbolo(prisma_2.default.CONCATENACAO);
+                }
+                else {
+                    this.adicionarSimbolo(prisma_2.default.PONTO);
+                }
+                break;
+            case '#':
+                this.adicionarSimbolo(prisma_2.default.COMPRIMENTO);
                 this.avancar();
                 break;
             case ';':
@@ -24343,6 +24727,10 @@ class LexadorPrisma {
                 this.adicionarSimbolo(prisma_2.default.DOIS_PONTOS);
                 this.avancar();
                 break;
+            case '?':
+                this.adicionarSimbolo(prisma_2.default.INTERROGACAO);
+                this.avancar();
+                break;
             case '=':
                 this.avancar();
                 if (this.simboloAtual() === '=') {
@@ -24424,10 +24812,8 @@ class LexadorPrisma {
             case '/':
                 this.avancar();
                 if (this.simboloAtual() === '/') {
-                    // Comentário de linha
-                    while (this.simboloAtual() !== '\n' && !this.eFinalDoCodigo()) {
-                        this.avancar();
-                    }
+                    // Comentário de linha — ignorar até o final da linha
+                    this.atual = this.codigo[this.linha].length;
                 }
                 else if (this.simboloAtual() === '*') {
                     // Comentário de bloco
@@ -24462,8 +24848,14 @@ class LexadorPrisma {
                 this.avancar();
                 break;
             case '~':
-                this.adicionarSimbolo(prisma_2.default.BIT_NOT);
                 this.avancar();
+                if (this.simboloAtual() === '=') {
+                    this.adicionarSimbolo(prisma_2.default.DIFERENTE);
+                    this.avancar();
+                }
+                else {
+                    this.adicionarSimbolo(prisma_2.default.BIT_XOR);
+                }
                 break;
             case '"':
                 this.avancar();
@@ -24919,16 +25311,43 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const calango_1 = __importDefault(require("../../../tipos-de-simbolos/calango"));
 exports.default = {
     algoritmo: calango_1.default.ALGORITMO,
-    principal: calango_1.default.PRINCIPAL,
-    fimPrincipal: calango_1.default.FIM_PRINCIPAL,
+    ate: calango_1.default.ATE,
+    caracter: calango_1.default.CARACTER,
+    caso: calango_1.default.CASO,
+    de: calango_1.default.DE,
+    div: calango_1.default.DIVISAO_INTEIRA,
+    escolha: calango_1.default.ESCOLHA,
+    enquanto: calango_1.default.ENQUANTO,
+    entao: calango_1.default.ENTAO,
     escreva: calango_1.default.ESCREVA,
     escreval: calango_1.default.ESCREVAL,
+    faca: calango_1.default.FACA,
+    falso: calango_1.default.FALSO,
+    fimEnquanto: calango_1.default.FIM_ENQUANTO,
+    fimEscolha: calango_1.default.FIM_ESCOLHA,
+    fimFuncao: calango_1.default.FIM_FUNCAO,
+    fimPara: calango_1.default.FIM_PARA,
+    fimProcedimento: calango_1.default.FIM_PROCEDIMENTO,
+    fimPrincipal: calango_1.default.FIM_PRINCIPAL,
+    fimSe: calango_1.default.FIM_SE,
+    outroCaso: calango_1.default.OUTRO_CASO,
+    procedimento: calango_1.default.PROCEDIMENTO,
     inteiro: calango_1.default.INTEIRO,
+    funcao: calango_1.default.FUNCAO,
+    interrompa: calango_1.default.INTERROMPA,
     leia: calango_1.default.LEIA,
+    logico: calango_1.default.LOGICO,
+    mod: calango_1.default.MODULO,
+    nao: calango_1.default.NEGACAO,
+    para: calango_1.default.PARA,
+    passo: calango_1.default.PASSO,
+    principal: calango_1.default.PRINCIPAL,
+    real: calango_1.default.REAL,
+    retorna: calango_1.default.RETORNA,
     se: calango_1.default.SE,
-    entao: calango_1.default.ENTAO,
     senao: calango_1.default.SENAO,
-    fimSe: calango_1.default.FIM_SE,
+    texto: calango_1.default.TIPO_TEXTO,
+    verdadeiro: calango_1.default.VERDADEIRO,
 };
 
 },{"../../../tipos-de-simbolos/calango":220}],201:[function(require,module,exports){
@@ -25102,6 +25521,8 @@ exports.palavrasReservadas = {
     leia: prisma_1.default.LEIA,
     local: prisma_1.default.LOCAL,
     nulo: prisma_1.default.NULO,
+    nao: prisma_1.default.NAO,
+    não: prisma_1.default.NAO,
     ou: prisma_1.default.OU,
     padrao: prisma_1.default.PADRAO,
     padrão: prisma_1.default.PADRAO,
@@ -25113,6 +25534,7 @@ exports.palavrasReservadas = {
     senao: prisma_1.default.SENAO,
     senão: prisma_1.default.SENÃO,
     super: prisma_1.default.SUPER,
+    quebra: prisma_1.default.QUEBRE,
     quebre: prisma_1.default.QUEBRE,
     tente: prisma_1.default.TENTE,
     verdadeiro: prisma_1.default.VERDADEIRO,
@@ -25610,13 +26032,13 @@ class Lexador {
         return this.codigo[this.linha].charAt(this.atual - 1);
     }
     analisarTexto(delimitador = '"') {
-        let textoCompleto = '';
+        let valor = '';
         this.avancar();
         while (!this.eFinalDoCodigo()) {
             const caractere = this.simboloAtual();
             if (caractere === delimitador) {
                 this.avancar();
-                this.adicionarSimbolo(delegua_1.default.TEXTO, textoCompleto.replace(/\\n/g, '\n'));
+                this.adicionarSimbolo(delegua_1.default.TEXTO, valor);
                 return;
             }
             if (caractere === '\0' && this.eUltimaLinha()) {
@@ -25628,11 +26050,62 @@ class Lexador {
                 return;
             }
             if (caractere === '\0') {
-                textoCompleto += '\n';
+                valor += '\n';
                 this.avancar();
                 continue;
             }
-            textoCompleto += caractere;
+            if (caractere === '\\') {
+                this.avancar();
+                const proximoCaractere = this.simboloAtual();
+                switch (proximoCaractere) {
+                    case 'n':
+                        valor += '\n';
+                        break;
+                    case 't':
+                        valor += '\t';
+                        break;
+                    case 'r':
+                        valor += '\r';
+                        break;
+                    case 'b':
+                        valor += '\b';
+                        break;
+                    case "'":
+                        valor += "'";
+                        break;
+                    case '"':
+                        valor += '"';
+                        break;
+                    case '\\':
+                        valor += '\\';
+                        break;
+                    case 'e':
+                        valor += '\x1B';
+                        break;
+                    case 'x': {
+                        let hex = '';
+                        for (let i = 0; i < 2; i++) {
+                            const c = this.proximoSimbolo();
+                            if (/[0-9a-fA-F]/.test(c)) {
+                                this.avancar();
+                                hex += c;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        valor += hex.length === 2 ? String.fromCharCode(parseInt(hex, 16)) : '\\x' + hex;
+                        break;
+                    }
+                    case '\0': break; // barra invertida no fim de linha: ignora e continua na próxima linha
+                    default:
+                        valor += '\\' + proximoCaractere;
+                        break;
+                }
+            }
+            else {
+                valor += caractere;
+            }
             this.avancar();
         }
         this.erros.push({
@@ -26901,14 +27374,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     ADICAO: 'ADICAO',
     ALGORITMO: 'ALGORITMO',
+    CARACTER: 'CARACTER',
     DIFERENTE: 'DIFERENTE',
     DIVISAO: 'DIVISAO',
     DIVISAO_INTEIRA: 'DIVISAO_INTEIRA',
     E: 'E',
+    ENQUANTO: 'ENQUANTO',
     ENTAO: 'ENTAO',
     ESCREVA: 'ESCREVA',
     ESCREVAL: 'ESCREVAL',
     EXPONENCIACAO: 'EXPONENCIACAO',
+    FACA: 'FACA',
+    FALSO: 'FALSO',
+    ATE: 'ATE',
+    CASO: 'CASO',
+    COLCHETE_DIREITO: 'COLCHETE_DIREITO',
+    COLCHETE_ESQUERDO: 'COLCHETE_ESQUERDO',
+    DE: 'DE',
+    DOIS_PONTOS: 'DOIS_PONTOS',
+    ESCOLHA: 'ESCOLHA',
+    FIM_ESCOLHA: 'FIM_ESCOLHA',
+    FIM_FUNCAO: 'FIM_FUNCAO',
+    FIM_PROCEDIMENTO: 'FIM_PROCEDIMENTO',
+    FUNCAO: 'FUNCAO',
+    FIM_ENQUANTO: 'FIM_ENQUANTO',
+    FIM_PARA: 'FIM_PARA',
     FIM_PRINCIPAL: 'FIM_PRINCIPAL',
     FIM_SE: 'FIM_SE',
     IDENTIFICADOR: 'IDENTIFICADOR',
@@ -26916,7 +27406,10 @@ exports.default = {
     IGUAL_ATRIBUICAO: 'IGUAL_ATRIBUICAO',
     IGUAL_IGUAL: 'IGUAL_IGUAL',
     INTEIRO: 'INTEIRO',
+    INTERROMPA: 'INTERROMPA',
     LEIA: 'LEIA',
+    LITERAL_CARACTER: 'LITERAL_CARACTER',
+    LOGICO: 'LOGICO',
     MAIOR: 'MAIOR',
     MAIOR_IGUAL: 'MAIOR_IGUAL',
     MENOR: 'MENOR',
@@ -26929,13 +27422,21 @@ exports.default = {
     PARENTESE_DIREITO: 'PARENTESE_DIREITO',
     PARENTESE_ESQUERDO: 'PARENTESE_ESQUERDO',
     PRINCIPAL: 'PRINCIPAL',
+    OUTRO_CASO: 'OUTRO_CASO',
+    PARA: 'PARA',
+    PROCEDIMENTO: 'PROCEDIMENTO',
+    PASSO: 'PASSO',
     PONTO: 'PONTO',
     PONTO_E_VIRGULA: 'PONTO_E_VIRGULA',
     QUEBRA_LINHA: 'QUEBRA_LINHA',
+    REAL: 'REAL',
+    RETORNA: 'RETORNA',
     SE: 'SE',
     SENAO: 'SENAO',
     SUBTRACAO: 'SUBTRACAO',
     TEXTO: 'TEXTO',
+    TIPO_TEXTO: 'TIPO_TEXTO',
+    VERDADEIRO: 'VERDADEIRO',
     VIRGULA: 'VIRGULA',
 };
 
@@ -27400,6 +27901,7 @@ exports.default = {
     IGUAL_IGUAL: 'IGUAL_IGUAL',
     IMPORTAR: 'IMPORTAR',
     INICIO: 'INICIO',
+    INTERROGACAO: 'INTERROGACAO',
     ISTO: 'ISTO',
     LEIA: 'LEIA',
     LOCAL: 'LOCAL',
@@ -27412,6 +27914,7 @@ exports.default = {
     MENOR_MENOR: 'MENOR_MENOR',
     MODULO: 'MODULO',
     MULTIPLICACAO: 'MULTIPLICACAO',
+    NAO: 'NAO',
     NEGACAO: 'NEGACAO',
     NULO: 'NULO',
     NUMERO: 'NUMERO',
@@ -27423,6 +27926,8 @@ exports.default = {
     PEGUE: 'PEGUE',
     PONTO: 'PONTO',
     PONTO_E_VIRGULA: 'PONTO_E_VIRGULA',
+    COMPRIMENTO: 'COMPRIMENTO',
+    CONCATENACAO: 'CONCATENACAO',
     QUEBRA_LINHA: 'QUEBRA_LINHA',
     RETORNE: 'RETORNE',
     SE: 'SE',
@@ -40965,10 +41470,10 @@ class TradutorAssemblyRISCV {
             Var: this.traduzirDeclaracaoVar.bind(this),
         };
         this.indentacao = 0;
-        this.text = `
-.text
-.global _start
-
+        this.text = `
+.text
+.global _start
+
 _start:`;
     }
     gerarDigitoAleatorio() {
@@ -41035,9 +41540,9 @@ _start:`;
         const reg = this.obterRegistrador();
         this.text += `\n    la ${reg}, ${nomeVar}`;
         this.emitirCarga('a0', indice);
-        this.text += `
-    slli a0, a0, 3          # multiplicar índice por 8 (palavra de 64 bits)
-    add ${reg}, ${reg}, a0
+        this.text += `
+    slli a0, a0, 3          # multiplicar índice por 8 (palavra de 64 bits)
+    add ${reg}, ${reg}, a0
     ld a0, 0(${reg})`;
         this.liberarRegistrador(reg);
         return 'a0';
@@ -41062,8 +41567,8 @@ _start:`;
         const reg = this.obterRegistrador();
         this.text += `\n    la ${reg}, ${nomeVar}`;
         this.emitirCarga('a1', indice);
-        this.text += `
-    slli a1, a1, 3          # multiplicar índice por 8
+        this.text += `
+    slli a1, a1, 3          # multiplicar índice por 8
     add ${reg}, ${reg}, a1`;
         this.emitirCarga('a1', valor);
         this.text += `\n    sd a1, 0(${reg})`;
@@ -41084,8 +41589,8 @@ _start:`;
             this.variaveis.set(nomeVar, varLabel);
         }
         this.emitirCarga('a0', valor);
-        this.text += `
-    la a1, ${this.variaveis.get(nomeVar)}
+        this.text += `
+    la a1, ${this.variaveis.get(nomeVar)}
     sd a0, 0(a1)`;
     }
     traduzirConstrutoBinario(construto) {
@@ -41170,18 +41675,18 @@ _start:`;
         const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
         const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
         this.emitirCarga('a0', valor);
-        this.text += `
-    la a1, ${objeto}
+        this.text += `
+    la a1, ${objeto}
     sd a0, 0(a1)`;
     }
     traduzirFuncaoConstruto(construto) {
         const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
-        this.text += `
-
-${labelFuncao}:
-    addi sp, sp, -16
-    sd   ra, 8(sp)
-    sd   s0, 0(sp)
+        this.text += `
+
+${labelFuncao}:
+    addi sp, sp, -16
+    sd   ra, 8(sp)
+    sd   s0, 0(sp)
     addi s0, sp, 16`;
         if (construto.corpo && Array.isArray(construto.corpo)) {
             construto.corpo.forEach((declaracao) => {
@@ -41190,10 +41695,10 @@ ${labelFuncao}:
                 }
             });
         }
-        this.text += `
-    ld   ra, 8(sp)
-    ld   s0, 0(sp)
-    addi sp, sp, 16
+        this.text += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
     ret`;
     }
     traduzirConstrutoLiteral(construto) {
@@ -41212,21 +41717,21 @@ ${labelFuncao}:
         if (operador === 'e' || operador === '&&') {
             this.text += `\n    beqz a0, ${labelFim}`;
             this.emitirCarga('a0', direita);
-            this.text += `
-    beqz a0, ${labelFim}
-${labelVerdadeiro}:
-    li a0, 1
+            this.text += `
+    beqz a0, ${labelFim}
+${labelVerdadeiro}:
+    li a0, 1
 ${labelFim}:`;
         }
         else if (operador === 'ou' || operador === '||') {
             this.text += `\n    bnez a0, ${labelVerdadeiro}`;
             this.emitirCarga('a0', direita);
-            this.text += `
-    bnez a0, ${labelVerdadeiro}
-    li a0, 0
-    j ${labelFim}
-${labelVerdadeiro}:
-    li a0, 1
+            this.text += `
+    bnez a0, ${labelVerdadeiro}
+    li a0, 0
+    j ${labelFim}
+${labelVerdadeiro}:
+    li a0, 1
 ${labelFim}:`;
         }
         return 'a0';
@@ -41252,8 +41757,8 @@ ${labelFim}:`;
         const nomeVar = (_a = construto.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
         if (nomeVar && this.variaveis.has(nomeVar)) {
             const varLabel = this.variaveis.get(nomeVar);
-            this.text += `
-    la a0, ${varLabel}
+            this.text += `
+    la a0, ${varLabel}
     ld a0, 0(a0)`;
             return 'a0';
         }
@@ -41269,8 +41774,8 @@ ${labelFim}:`;
             if (this.dicionarioConstrutos[valor.constructor.name]) {
                 const valorTraduzido = this.dicionarioConstrutos[valor.constructor.name](valor);
                 this.emitirCarga('a0', valorTraduzido);
-                this.text += `
-    la a1, ${labelVetor}
+                this.text += `
+    la a1, ${labelVetor}
     sd a0, ${index * 8}(a1)`;
             }
         });
@@ -41298,8 +41803,8 @@ ${labelFim}:`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
-    j ${labelInicio}
+        this.text += `
+    j ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoEscolha(declaracao) {
@@ -41320,8 +41825,8 @@ ${labelFim}:`;
                             }
                         });
                     }
-                    this.text += `
-    j ${labelFim}
+                    this.text += `
+    j ${labelFim}
 ${labelProximo}:`;
                 }
             });
@@ -41362,21 +41867,21 @@ ${labelProximo}:`;
                 mensagem = this.dicionarioConstrutos[explicacao.constructor.name](explicacao);
             }
         }
-        this.text += `
-    # Falhar com mensagem: ${mensagem}
-    li a0, 1
-    li a7, 93               # sys_exit
+        this.text += `
+    # Falhar com mensagem: ${mensagem}
+    li a0, 1
+    li a7, 93               # sys_exit
     ecall`;
     }
     traduzirDeclaracaoFuncao(declaracao) {
         var _a;
         const nomeFuncao = ((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
-        this.text += `
-
-${nomeFuncao}:
-    addi sp, sp, -16
-    sd   ra, 8(sp)
-    sd   s0, 0(sp)
+        this.text += `
+
+${nomeFuncao}:
+    addi sp, sp, -16
+    sd   ra, 8(sp)
+    sd   s0, 0(sp)
     addi s0, sp, 16`;
         if (declaracao.funcao &&
             declaracao.funcao.corpo &&
@@ -41387,10 +41892,10 @@ ${nomeFuncao}:
                 }
             });
         }
-        this.text += `
-    ld   ra, 8(sp)
-    ld   s0, 0(sp)
-    addi sp, sp, 16
+        this.text += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
     ret`;
     }
     traduzirDeclaracaoImportar(declaracao) {
@@ -41411,11 +41916,11 @@ ${nomeFuncao}:
             this.bss += `    ${varLabel}: .space 256\n`;
             this.variaveis.set(nomeVar, varLabel);
         }
-        this.text += `
-    li a0, 0                # fd stdin
-    la a1, ${this.variaveis.get(nomeVar)}
-    li a2, 256
-    li a7, 63               # sys_read
+        this.text += `
+    li a0, 0                # fd stdin
+    la a1, ${this.variaveis.get(nomeVar)}
+    li a2, 256
+    li a7, 63               # sys_read
     ecall`;
     }
     traduzirDeclaracaoPara(declaracao) {
@@ -41446,8 +41951,8 @@ ${nomeFuncao}:
                 this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
             }
         }
-        this.text += `
-    j ${labelInicio}
+        this.text += `
+    j ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoParaCada(declaracao) {
@@ -41459,17 +41964,17 @@ ${labelFim}:`;
             tamanhoVetor = vetor.tamanho || 0;
         }
         // t0: contador; t1: limite (caller-saved, seguros aqui)
-        this.text += `
-    li t0, 0                # contador
-    li t1, ${tamanhoVetor}
-${labelInicio}:
+        this.text += `
+    li t0, 0                # contador
+    li t1, ${tamanhoVetor}
+${labelInicio}:
     bge t0, t1, ${labelFim}`;
         if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
         }
-        this.text += `
-    addi t0, t0, 1
-    j ${labelInicio}
+        this.text += `
+    addi t0, t0, 1
+    j ${labelInicio}
 ${labelFim}:`;
     }
     traduzirDeclaracaoRetorna(declaracao) {
@@ -41477,10 +41982,10 @@ ${labelFim}:`;
             const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
             this.emitirCarga('a0', valor);
         }
-        this.text += `
-    ld   ra, 8(sp)
-    ld   s0, 0(sp)
-    addi sp, sp, 16
+        this.text += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
     ret`;
     }
     traduzirDeclaracaoSe(declaracao) {
@@ -41494,8 +41999,8 @@ ${labelFim}:`;
         if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
             this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
         }
-        this.text += `
-    j ${labelFim}
+        this.text += `
+    j ${labelFim}
 ${labelSenao}:`;
         if (declaracao.caminhoSenao &&
             this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
@@ -41544,8 +42049,8 @@ ${labelSenao}:`;
             else if (this.dicionarioConstrutos[tipoInicializador]) {
                 const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
                 this.emitirCarga('a0', valor);
-                this.text += `
-    la a1, ${varLabel}
+                this.text += `
+    la a1, ${varLabel}
     sd a0, 0(a1)`;
             }
         }
@@ -41567,17 +42072,17 @@ ${labelSenao}:`;
             tamanhoString = String(stringValue.length);
         }
         // sys_write(fd=1, buf, count): a7=64, a0=fd, a1=buf, a2=count
-        this.text += `
-    la a1, ${nomeStringLiteral}
-    li a2, ${tamanhoString}
-    li a0, 1                # fd stdout
-    li a7, 64               # sys_write
+        this.text += `
+    la a1, ${nomeStringLiteral}
+    li a2, ${tamanhoString}
+    li a0, 1                # fd stdout
+    li a7, 64               # sys_write
     ecall`;
     }
     saidaSistema() {
-        this.text += `
-    li a0, 0                # código de saída
-    li a7, 93               # sys_exit
+        this.text += `
+    li a0, 0                # código de saída
+    li a7, 93               # sys_exit
     ecall`;
     }
     traduzir(declaracoes) {
@@ -43148,7 +43653,7 @@ class TradutorAssemblyScript {
         let resultado = '';
         this.indentacao += 4;
         resultado += ' '.repeat(this.indentacao);
-        for (let condicao of (caminho.condicoes || [])) {
+        for (let condicao of caminho.condicoes || []) {
             resultado +=
                 'case ' + this.dicionarioConstrutos[condicao.constructor.name](condicao) + ':\n';
             resultado += ' '.repeat(this.indentacao);
@@ -43513,9 +44018,72 @@ class TradutorAssemblyScript {
     traduzirConstrutoAgrupamento(agrupamento) {
         return this.dicionarioConstrutos[agrupamento.constructor.name](agrupamento.expressao || agrupamento);
     }
+    detectarImportacoesNecessarias(declaracoes) {
+        const importsNecessarios = new Set();
+        this.varrerDeclaracoesParaImports(declaracoes, importsNecessarios);
+        if (importsNecessarios.size === 0) {
+            return '';
+        }
+        return Array.from(importsNecessarios).join('\n') + '\n\n';
+    }
+    varrerDeclaracoesParaImports(declaracoes, imports) {
+        for (const declaracao of declaracoes) {
+            const nome = declaracao.constructor.name;
+            if (nome === 'Escreva' || nome === 'EscrevaMesmaLinha') {
+                imports.add('import "wasi";');
+            }
+            else if (nome === 'Bloco') {
+                this.varrerDeclaracoesParaImports(declaracao.declaracoes, imports);
+            }
+            else if (nome === 'Se') {
+                const se = declaracao;
+                if (se.caminhoEntao) {
+                    this.varrerDeclaracoesParaImports([se.caminhoEntao], imports);
+                }
+                if (se.caminhoSenao) {
+                    this.varrerDeclaracoesParaImports([se.caminhoSenao], imports);
+                }
+            }
+            else if (nome === 'Enquanto') {
+                const enquanto = declaracao;
+                this.varrerDeclaracoesParaImports([enquanto.corpo], imports);
+            }
+            else if (nome === 'Para') {
+                const para = declaracao;
+                this.varrerDeclaracoesParaImports([para.corpo], imports);
+            }
+            else if (nome === 'ParaCada') {
+                const paraCada = declaracao;
+                this.varrerDeclaracoesParaImports([paraCada.corpo], imports);
+            }
+            else if (nome === 'Fazer') {
+                const fazer = declaracao;
+                this.varrerDeclaracoesParaImports([fazer.caminhoFazer], imports);
+            }
+            else if (nome === 'FuncaoDeclaracao') {
+                const funcao = declaracao;
+                this.varrerDeclaracoesParaImports(funcao.funcao.corpo, imports);
+            }
+            else if (nome === 'Classe') {
+                const classe = declaracao;
+                this.varrerDeclaracoesParaImports(classe.metodos, imports);
+            }
+            else if (nome === 'Tente') {
+                const tente = declaracao;
+                this.varrerDeclaracoesParaImports(tente.caminhoTente, imports);
+                if (Array.isArray(tente.caminhoPegue)) {
+                    this.varrerDeclaracoesParaImports(tente.caminhoPegue, imports);
+                }
+                if (tente.caminhoFinalmente && tente.caminhoFinalmente.length > 0) {
+                    this.varrerDeclaracoesParaImports(tente.caminhoFinalmente, imports);
+                }
+            }
+        }
+    }
     traduzir(declaracoes) {
         let resultado = '';
         this.declaracoesDeClasses = declaracoes.filter((declaracao) => declaracao instanceof declaracoes_1.Classe);
+        resultado += this.detectarImportacoesNecessarias(declaracoes);
         for (const declaracao of declaracoes) {
             resultado += `${this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao)} \n`;
         }
@@ -48914,19 +49482,30 @@ class TradutorWebAssembly {
         const dir = this.traduzirConstruto(construto.direita);
         const op = construto.operador.lexema;
         switch (op) {
-            case '+': return `(i64.add ${esq} ${dir})`;
-            case '-': return `(i64.sub ${esq} ${dir})`;
-            case '*': return `(i64.mul ${esq} ${dir})`;
-            case '/': return `(i64.div_s ${esq} ${dir})`;
-            case '%': return `(i64.rem_s ${esq} ${dir})`;
-            case '<': return `(i64.extend_i32_s (i64.lt_s ${esq} ${dir}))`;
-            case '>': return `(i64.extend_i32_s (i64.gt_s ${esq} ${dir}))`;
-            case '<=': return `(i64.extend_i32_s (i64.le_s ${esq} ${dir}))`;
-            case '>=': return `(i64.extend_i32_s (i64.ge_s ${esq} ${dir}))`;
+            case '+':
+                return `(i64.add ${esq} ${dir})`;
+            case '-':
+                return `(i64.sub ${esq} ${dir})`;
+            case '*':
+                return `(i64.mul ${esq} ${dir})`;
+            case '/':
+                return `(i64.div_s ${esq} ${dir})`;
+            case '%':
+                return `(i64.rem_s ${esq} ${dir})`;
+            case '<':
+                return `(i64.extend_i32_s (i64.lt_s ${esq} ${dir}))`;
+            case '>':
+                return `(i64.extend_i32_s (i64.gt_s ${esq} ${dir}))`;
+            case '<=':
+                return `(i64.extend_i32_s (i64.le_s ${esq} ${dir}))`;
+            case '>=':
+                return `(i64.extend_i32_s (i64.ge_s ${esq} ${dir}))`;
             case '==':
-            case '===': return `(i64.extend_i32_s (i64.eq ${esq} ${dir}))`;
+            case '===':
+                return `(i64.extend_i32_s (i64.eq ${esq} ${dir}))`;
             case '!=':
-            case '!==': return `(i64.extend_i32_s (i64.ne ${esq} ${dir}))`;
+            case '!==':
+                return `(i64.extend_i32_s (i64.ne ${esq} ${dir}))`;
             default:
                 return `(i64.const 0) ;; operador não suportado: ${op}`;
         }
@@ -49458,12 +50037,7 @@ class TradutorWebAssembly {
             const { watLiteral } = this.escaparStringWat(s.conteudo);
             return `  (data (i32.const ${s.deslocamento}) "${watLiteral}")`;
         });
-        const partes = [
-            '(module',
-            ...linhasImports,
-            '',
-            linhaMemoria,
-        ];
+        const partes = ['(module', ...linhasImports, '', linhaMemoria];
         if (linhasDados.length > 0) {
             partes.push('');
             partes.push(...linhasDados);
@@ -49487,35 +50061,35 @@ class TradutorWebAssembly {
      * Fornece os imports necessários (`delegua.escreva_texto`, `delegua.escreva_inteiro`).
      */
     gerarArquivoHost() {
-        return `// Gerado por Delégua -> WebAssembly
-// Uso: node delegua-host.mjs <arquivo.wasm>
-import { readFileSync } from 'fs';
-
-const args = process.argv.slice(2);
-const wasmPath = args[0] ?? 'saida.wasm';
-
-let memoryExport;
-
-const importObject = {
-    delegua: {
-        /** Imprime texto a partir de um ponteiro e comprimento na memória linear. */
-        escreva_texto(ptr, len) {
-            const bytes = new Uint8Array(memoryExport.buffer, ptr, len);
-            process.stdout.write(new TextDecoder('utf-8').decode(bytes));
-        },
-        /** Imprime um inteiro de 64 bits (recebido como BigInt no JS). */
-        escreva_inteiro(valor) {
-            process.stdout.write(String(valor));
-        },
-    }
-};
-
-const wasmBuffer = readFileSync(wasmPath);
-const { instance } = await WebAssembly.instantiate(wasmBuffer, importObject);
-memoryExport = instance.exports.memory;
-
-const codigoSaida = Number(instance.exports.principal());
-process.exit(codigoSaida);
+        return `// Gerado por Delégua -> WebAssembly
+// Uso: node delegua-host.mjs <arquivo.wasm>
+import { readFileSync } from 'fs';
+
+const args = process.argv.slice(2);
+const wasmPath = args[0] ?? 'saida.wasm';
+
+let memoryExport;
+
+const importObject = {
+    delegua: {
+        /** Imprime texto a partir de um ponteiro e comprimento na memória linear. */
+        escreva_texto(ptr, len) {
+            const bytes = new Uint8Array(memoryExport.buffer, ptr, len);
+            process.stdout.write(new TextDecoder('utf-8').decode(bytes));
+        },
+        /** Imprime um inteiro de 64 bits (recebido como BigInt no JS). */
+        escreva_inteiro(valor) {
+            process.stdout.write(String(valor));
+        },
+    }
+};
+
+const wasmBuffer = readFileSync(wasmPath);
+const { instance } = await WebAssembly.instantiate(wasmBuffer, importObject);
+memoryExport = instance.exports.memory;
+
+const codigoSaida = Number(instance.exports.principal());
+process.exit(codigoSaida);
 `;
     }
 }