Repository: DesignLiquido/delegua
Pull request #390 (2023-05-20 03:11:12)

#384 Melhoria micro lexador e testes para interpolação
Em andamento: https://github.com/DesignLiquido/delegua/issues/384


Patch:
diff --git a/.vscode/launch.json b/.vscode/launch.json
index d4340fdf..784224d1 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -12,7 +12,6 @@
                 "--inspect-brk",
                 "${workspaceRoot}/node_modules/jest/bin/jest.js",
                 "birl/interpretador.test.ts",
-                // "birl/lexador.test.ts",
                 "--runInBand"
             ],
             "console": "integratedTerminal",
@@ -637,7 +636,7 @@
             "runtimeArgs": [
                 "--inspect-brk",
                 "${workspaceRoot}/node_modules/jest/bin/jest.js",
-                "micro-avaliador-sintatico",
+                "interpretador",
                 "--runInBand"
             ],
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts
index 545c3127..41f517de 100644
--- a/fontes/analisador-semantico/analisador-semantico.ts
+++ b/fontes/analisador-semantico/analisador-semantico.ts
@@ -155,7 +155,7 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
     visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
         return Promise.resolve();
     }
-    
+
     visitarDeclaracaoVar(declaracao: Var): Promise<any> {
         this.variaveis[declaracao.simbolo.lexema] = {
             imutavel: false,
@@ -195,7 +195,7 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
     visitarExpressaoDeleguaFuncao(expressao: any) {
         return Promise.resolve();
     }
-    visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any> {
+    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
         return Promise.resolve();
     }
     visitarExpressaoAcessoIndiceVariavel(expressao: any) {
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
index 08e142c0..14f7c413 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
@@ -108,6 +108,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
     abstract chamar(): Construto;
 
     unario(): Construto {
+
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NEGACAO, tiposDeSimbolos.SUBTRACAO)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index 75806a86..40eb288b 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -3,7 +3,7 @@ import hrtime from 'browser-process-hrtime';
 
 import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
 import {
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -49,7 +49,7 @@ import {
 } from '../declaracoes';
 import { RetornoAvaliadorSintatico } from '../interfaces/retornos/retorno-avaliador-sintatico';
 import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
-import { RetornoDeclaracao, RetornoResolverDeclaracao } from './retornos';
+import { RetornoDeclaracao } from './retornos';
 
 /**
  * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
@@ -458,7 +458,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
     /**
      * Método que resolve atribuições.
-     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoSobrescrita`.
+     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
      */
     atribuir(): Construto {
         const expressao = this.ou();
@@ -487,7 +487,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
                 // return new Conjunto(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
                 return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
                     expressao.entidadeChamada,
@@ -595,12 +595,12 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     }
 
     protected declaracaoParaCada(simboloPara: SimboloInterface): ParaCada {
-        const nomeVariavelIteracao = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 
+        const nomeVariavelIteracao = this.consumir(tiposDeSimbolos.IDENTIFICADOR,
             "Esperado identificador de variável de iteração para instrução 'para cada'.");
-        
+
         if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DE, tiposDeSimbolos.EM)) {
             throw this.erro(
-                this.simbolos[this.atual], 
+                this.simbolos[this.atual],
                 "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução 'para cada'."
             );
         }
@@ -609,10 +609,10 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         const corpo = this.resolverDeclaracao();
 
         return new ParaCada(
-            this.hashArquivo, 
-            Number(simboloPara.linha), 
-            nomeVariavelIteracao.lexema, 
-            vetor, 
+            this.hashArquivo,
+            Number(simboloPara.linha),
+            nomeVariavelIteracao.lexema,
+            vetor,
             corpo
         );
     }
@@ -663,7 +663,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CADA)) {
                 return this.declaracaoParaCada(simboloPara);
-            } 
+            }
 
             return this.declaracaoParaTradicional(simboloPara);
         } finally {
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
index a91f826e..2013d0c6 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
@@ -2,12 +2,13 @@ import {
     AcessoIndiceVariavel,
     AcessoMetodo,
     Agrupamento,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Chamada,
     DefinirValor,
     FuncaoConstruto,
     Literal,
+    Unario,
     Variavel,
 } from '../../construtos';
 import {
@@ -89,9 +90,9 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
     primario(): Construto {
         const simboloAtual = this.simbolos[this.atual];
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NEGATIVO))
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUBTRACAO))
             return new Literal(this.hashArquivo, Number(simboloAtual.linha), false);
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.POSITIVO))
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ADICAO))
             return new Literal(this.hashArquivo, Number(simboloAtual.linha), true);
 
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)) {
@@ -137,13 +138,7 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
                 const get = expressao;
                 return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
-                    this.hashArquivo,
-                    0,
-                    expressao.entidadeChamada,
-                    expressao.indice,
-                    valor
-                );
+                return new AtribuicaoPorIndice(this.hashArquivo, 0, expressao.entidadeChamada, expressao.indice, valor);
             }
             this.erro(igual, 'Tarefa de atribuição inválida');
         }
@@ -199,7 +194,7 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
             'Esperado expressão `(` após `MAIS` para iniciar o bloco `PARA`.'
         );
 
-        let declaracaoInicial: any = null;
+        let declaracaoInicial: Var | Expressao | null = null;
 
         if (this.simbolos[this.atual].tipo === tiposDeSimbolos.IDENTIFICADOR) {
             this.consumir(
@@ -229,12 +224,10 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
 
         this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, 'Esperado expressão `;` após a condição do `PARA`.');
 
-        const incremento: Array<any> = [];
+        const incremento = this.declaracao();
 
-        while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_DIREITO)) {
-            incremento.push(this.simbolos[this.atual]);
-            this.avancarEDevolverAnterior();
-        }
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, 'Esperado expressão `)` após a condição do `PARA`.');
+        this.consumir(tiposDeSimbolos.QUEBRA_LINHA, 'Esperado expressão `QUEBRA_LINHA` após a condição do `PARA`.');
 
         const declaracoes = [];
 
@@ -242,25 +235,18 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
             declaracoes.push(this.declaracao());
         }
 
-        const incrementoValor = this.tratarSimbolos(incremento);
-
-        const incrementoConstruto: Construto = new Literal(
-            this.hashArquivo,
-            Number(primeiroSimbolo.linha) + 1,
-            incrementoValor as string
-        );
         const corpo = new Bloco(
             this.hashArquivo,
-            Number(primeiroSimbolo.linha) + 1,
+            Number(this.simbolos[this.atual].linha) + 1,
             declaracoes.filter((d) => d)
         );
 
         return new Para(
             this.hashArquivo,
-            Number(primeiroSimbolo.linha),
+            Number(this.simbolos[this.atual].linha),
             declaracaoInicial,
             condicao,
-            incrementoConstruto,
+            incremento,
             corpo
         );
     }
@@ -308,9 +294,6 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
                 tiposDeSimbolos.IDENTIFICADOR,
                 "Esperado identificador após palavra reservada 'FRANGO'."
             );
-            inicializacoes.push(
-                new Var(identificador, new Literal(this.hashArquivo, Number(simboloCaractere.hashArquivo), 0), 'texto')
-            );
 
             // Inicialização de variáveis que podem ter valor definido;
             let valorInicializacao: string | Array<string>;
@@ -322,15 +305,22 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
                 );
                 this.consumir(tiposDeSimbolos.TEXTO, "Esperado ' para terminar o texto.");
                 valorInicializacao = String(literalInicializacao.literal);
+                inicializacoes.push(
+                    new Var(
+                        identificador,
+                        new Literal(this.hashArquivo, Number(simboloCaractere.linha), valorInicializacao),
+                        'texto'
+                    )
+                );
+            } else {
+                inicializacoes.push(
+                    new Var(
+                        identificador,
+                        new Literal(this.hashArquivo, Number(simboloCaractere.hashArquivo), 0),
+                        'texto'
+                    )
+                );
             }
-
-            inicializacoes.push(
-                new Var(
-                    identificador,
-                    new Literal(this.hashArquivo, Number(simboloCaractere.linha), valorInicializacao),
-                    'texto'
-                )
-            );
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
         return inicializacoes;
@@ -671,7 +661,6 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
     }
 
     declaracaoChamaFuncao(): Chamada {
-
         const declaracaoInicio = this.consumir(tiposDeSimbolos.AJUDA, 'Esperado expressão `AJUDA`.');
         this.consumir(tiposDeSimbolos.O, 'Esperado expressão `O` após `AJUDA`.');
         this.consumir(tiposDeSimbolos.MALUCO, 'Esperado expressão `MALUCO` após `O`.');
@@ -691,14 +680,34 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
         this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, 'Esperado parêntese direito após lista de parâmetros.');
         this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, 'Esperado ponto e vírgula após a chamada de função.');
 
-
-
         return new Chamada(declaracaoInicio.hashArquivo, expressao, null, paramentros);
     }
 
     declaracao(): any {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
+            case tiposDeSimbolos.INCREMENTAR:
+            case tiposDeSimbolos.DECREMENTAR:
+                let adicionaOuSubtrai;
+                if ([tiposDeSimbolos.INCREMENTAR, tiposDeSimbolos.DECREMENTAR].includes(simboloAtual.tipo)) {
+                    adicionaOuSubtrai = this.consumir(
+                        tiposDeSimbolos[simboloAtual.tipo],
+                        'Esperado expressão `INCREMENTAR` ou `DECREMENTAR`.'
+                    );
+                }
+                if (this.verificarTipoSimboloAtual(tiposDeSimbolos.IDENTIFICADOR)) {
+                    const identificador = this.consumir(
+                        tiposDeSimbolos.IDENTIFICADOR,
+                        'Esperado expressão `IDENTIFICADOR`.'
+                    );
+                    return new Unario(
+                        this.hashArquivo,
+                        adicionaOuSubtrai,
+                        new Variavel(this.hashArquivo, identificador),
+                        'ANTES'
+                    );
+                }
+                return;
             case tiposDeSimbolos.BORA:
                 return this.declaracaoRetorna();
             case tiposDeSimbolos.SAI:
@@ -732,6 +741,26 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
             case tiposDeSimbolos.QUEBRA_LINHA:
                 this.avancarEDevolverAnterior();
                 return null;
+            case tiposDeSimbolos.IDENTIFICADOR:
+                const simboloIdentificador: SimboloInterface = this.simbolos[this.atual];
+                if (
+                    this.simbolos[this.atual + 1] &&
+                    [tiposDeSimbolos.DECREMENTAR, tiposDeSimbolos.INCREMENTAR].includes(
+                        this.simbolos[this.atual + 1].tipo
+                    )
+                ) {
+                    this.avancarEDevolverAnterior();
+                    const simboloIncrementoDecremento: SimboloInterface = this.avancarEDevolverAnterior();
+                    return new Unario(
+                        this.hashArquivo,
+                        simboloIncrementoDecremento,
+                        new Variavel(this.hashArquivo, simboloIdentificador),
+                        'DEPOIS'
+                    );
+                } else {
+                    return this.expressao();
+                }
+
             default:
                 return this.expressao();
         }
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
index 6e3c9f97..334c195c 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
@@ -1,6 +1,6 @@
 import { AvaliadorSintaticoInterface, SimboloInterface } from '../../interfaces';
 import {
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -426,7 +426,7 @@ export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterfa
                 const get = expressao;
                 return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     0,
                     expressao.entidadeChamada,
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
index fa69216a..e3f37523 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
@@ -4,7 +4,7 @@ import {
     AcessoIndiceVariavel,
     AcessoMetodo,
     Agrupamento,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -451,7 +451,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
             } else if (expressao instanceof AcessoMetodo) {
                 return new DefinirValor(this.hashArquivo, 0, expressao.objeto, expressao.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     0,
                     expressao.entidadeChamada,
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts
index a43a97cd..ca2cf72d 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts
@@ -1,4 +1,4 @@
-import { AcessoIndiceVariavel, AcessoMetodo, AtribuicaoSobrescrita, Atribuir, Binario, Construto, DefinirValor, FuncaoConstruto, Literal, Variavel } from "../../construtos";
+import { AcessoIndiceVariavel, AcessoMetodo, AtribuicaoPorIndice, Atribuir, Binario, Construto, DefinirValor, FuncaoConstruto, Literal, Variavel } from "../../construtos";
 import { Escreva, Declaracao, Se, Enquanto, Para, Escolha, Fazer } from "../../declaracoes";
 import { RetornoLexador, RetornoAvaliadorSintatico } from "../../interfaces/retornos";
 import { AvaliadorSintaticoBase } from "../avaliador-sintatico-base";
@@ -68,7 +68,7 @@ export class AvaliadorSintaticoGuarani extends AvaliadorSintaticoBase {
                 // return new Conjunto(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
                 return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     0,
                     expressao.entidadeChamada,
@@ -176,4 +176,4 @@ export class AvaliadorSintaticoGuarani extends AvaliadorSintaticoBase {
             erros: this.erros,
         } as RetornoAvaliadorSintatico;
     }
-}
\ No newline at end of file
+}
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts
index 14856ed1..f85dcf9c 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts
@@ -17,7 +17,7 @@ import {
 import {
     AcessoIndiceVariavel,
     Agrupamento,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -72,7 +72,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         return dimensoes;
     }
 
-    private logicaComumParametroMapler(): 
+    private logicaComumParametroMapler():
         { identificadores: SimboloInterface[], tipo: string, simbolo: SimboloInterface }
     {
         const identificadores = [];
@@ -115,7 +115,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.INICIO)) {
 
             const simboloAtual = this.simbolos[this.atual];
-            
+
             switch (simboloAtual.tipo) {
                 // case tiposDeSimbolos.PROCEDIMENTO:
                 //     const dadosProcedimento = this.declaracaoProcedimento();
@@ -259,7 +259,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
 
     /**
      * Método que resolve atribuições.
-     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoSobrescrita`.
+     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
      */
     atribuir(): Construto {
         const expressao = this.ou();
@@ -272,7 +272,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
                 const simbolo = expressao.simbolo;
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
                     expressao.entidadeChamada,
@@ -296,9 +296,9 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         const declaracoes = [];
 
         // while (![
-        //         tiposDeSimbolos.FIM_FUNCAO, 
+        //         tiposDeSimbolos.FIM_FUNCAO,
         //         tiposDeSimbolos.FIM_PROCEDIMENTO
-        //     ].includes(this.simbolos[this.atual].tipo) && !this.estaNoFinal()) 
+        //     ].includes(this.simbolos[this.atual].tipo) && !this.estaNoFinal())
         // {
         //     declaracoes.push(this.declaracao());
         // }
@@ -380,10 +380,10 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         );
 
         return new Enquanto(
-            condicao, 
+            condicao,
             new Bloco(
-                simboloAtual.hashArquivo, 
-                Number(simboloAtual.linha), 
+                simboloAtual.hashArquivo,
+                Number(simboloAtual.linha),
                 declaracoes.filter(d => d)
             )
         );
@@ -599,7 +599,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
 
     //         // Consumir parêntese direito
     //         this.consumir(
-    //             tiposDeSimbolos.PARENTESE_DIREITO, 
+    //             tiposDeSimbolos.PARENTESE_DIREITO,
     //             "Esperado parêntese direito para finalização da leitura de parâmetros."
     //         )
     //     }
@@ -613,7 +613,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
     // declaracaoProcedimento() {
     //     const simboloProcedimento: SimboloInterface = this.avancarEDevolverAnterior();
 
-    //     const nomeProcedimento = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 
+    //     const nomeProcedimento = this.consumir(tiposDeSimbolos.IDENTIFICADOR,
     //         "Esperado nome do procedimento após palavra-chave `procedimento`.");
 
     //     // Parâmetros
@@ -626,9 +626,9 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
 
     //     return new FuncaoDeclaracao(
     //         nomeProcedimento, new FuncaoConstruto(
-    //             this.hashArquivo, 
-    //             Number(simboloProcedimento.linha), 
-    //             parametros, 
+    //             this.hashArquivo,
+    //             Number(simboloProcedimento.linha),
+    //             parametros,
     //             corpo.filter(d => d)
     //         )
     //     );
@@ -650,19 +650,19 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO)) {
                 const simboloSenao = this.simbolos[this.atual - 1];
                 const declaracoesSenao = [];
-    
+
                 do {
                     declaracoesSenao.push(this.declaracao());
                 } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo)
                         && ![tiposDeSimbolos.SE].includes(this.simbolos[this.atual + 1].tipo));
-    
+
                 caminhoSenao = new Bloco(
                     this.hashArquivo,
                     Number(simboloSenao.linha),
                     declaracoesSenao.filter((d) => d)
                 );
             }
-        } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo) 
+        } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo)
                 && ![tiposDeSimbolos.SE].includes(this.simbolos[this.atual + 1].tipo));
 
         this.consumir(
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts
index 938c97fe..079f0b38 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts
@@ -1,4 +1,4 @@
-import { AcessoIndiceVariavel, AtribuicaoSobrescrita, Atribuir, Construto, FormatacaoEscrita, FuncaoConstruto, Literal, Variavel } from "../../construtos";
+import { AcessoIndiceVariavel, AtribuicaoPorIndice, Atribuir, Construto, FormatacaoEscrita, FuncaoConstruto, Literal, Variavel } from "../../construtos";
 import { Escreva, Declaracao, Se, Enquanto, Para, Escolha, Fazer, EscrevaMesmaLinha, Var, Leia } from "../../declaracoes";
 import { RetornoLexador, RetornoAvaliadorSintatico } from "../../interfaces/retornos";
 import { AvaliadorSintaticoBase } from "../avaliador-sintatico-base";
@@ -41,7 +41,7 @@ export class AvaliadorSintaticoPortugolIpt extends AvaliadorSintaticoBase {
                 const simbolo = expressao.simbolo;
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
                     expressao.entidadeChamada,
@@ -215,4 +215,4 @@ export class AvaliadorSintaticoPortugolIpt extends AvaliadorSintaticoBase {
             erros: this.erros,
         } as RetornoAvaliadorSintatico;
     }
-}
\ No newline at end of file
+}
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
index 896e1c0b..da5e1478 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
@@ -1,6 +1,6 @@
 import {
     AcessoIndiceVariavel,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Chamada,
     Construto,
@@ -133,7 +133,7 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
                 const simbolo = expressao.simbolo;
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
                     expressao.entidadeChamada,
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
index 15078d11..d7acc884 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
@@ -20,7 +20,7 @@ import {
 import {
     AcessoIndiceVariavel,
     Agrupamento,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -99,7 +99,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         return dimensoes;
     }
 
-    private logicaComumParametroVisuAlg(): 
+    private logicaComumParametroVisuAlg():
         { identificadores: SimboloInterface[], tipo: string, simbolo: SimboloInterface }
     {
         const identificadores = [];
@@ -330,7 +330,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
 
     /**
      * Método que resolve atribuições.
-     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoSobrescrita`.
+     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
      */
     atribuir(): Construto {
         const expressao = this.ou();
@@ -343,7 +343,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
                 const simbolo = expressao.simbolo;
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
                     expressao.entidadeChamada,
@@ -367,9 +367,9 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         const declaracoes = [];
 
         while (![
-                tiposDeSimbolos.FIM_FUNCAO, 
+                tiposDeSimbolos.FIM_FUNCAO,
                 tiposDeSimbolos.FIM_PROCEDIMENTO
-            ].includes(this.simbolos[this.atual].tipo) && !this.estaNoFinal()) 
+            ].includes(this.simbolos[this.atual].tipo) && !this.estaNoFinal())
         {
             declaracoes.push(this.declaracao());
         }
@@ -427,9 +427,9 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             .concat(this.blocoEscopo());
 
         return new FuncaoConstruto(
-            this.hashArquivo, 
-            Number(simboloAnterior.linha), 
-            parametros, 
+            this.hashArquivo,
+            Number(simboloAnterior.linha),
+            parametros,
             corpo.filter(d => d)
         );
     }
@@ -462,10 +462,10 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após palavra-chave 'fimenquanto'.");
 
         return new Enquanto(
-            condicao, 
+            condicao,
             new Bloco(
-                simboloAtual.hashArquivo, 
-                Number(simboloAtual.linha), 
+                simboloAtual.hashArquivo,
+                Number(simboloAtual.linha),
                 declaracoes.filter(d => d)
             )
         );
@@ -539,7 +539,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         }
 
         if (simboloAtualBlocoCaso.tipo !== tiposDeSimbolos.FIM_ESCOLHA) {
-            throw this.erro(this.simbolos[this.atual], 
+            throw this.erro(this.simbolos[this.atual],
                 "Esperado palavra-chave 'fimescolha' para fechamento de declaração 'escolha'.");
         }
 
@@ -559,8 +559,8 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         if (this.simbolos[this.atual].tipo === tiposDeSimbolos.PARENTESE_DIREITO) {
             this.avancarEDevolverAnterior();
             return [new FormatacaoEscrita(
-                this.hashArquivo, 
-                Number(simboloParenteses.linha), 
+                this.hashArquivo,
+                Number(simboloParenteses.linha),
                 new Literal(this.hashArquivo, Number(simboloParenteses.linha), ''))
             ]
         }
@@ -721,7 +721,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
 
         // Isso existe porque o laço `para` do VisuAlg pode ter o passo positivo ou negativo
         // dependendo dos operandos de início e fim, que só são possíveis de determinar
-        // em tempo de execução. 
+        // em tempo de execução.
         // Quando um dos operandos é uma variável, tanto a condição do laço quanto o
         // passo são considerados indefinidos aqui.
         let passo: Construto;
@@ -732,14 +732,14 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             if (literalOuVariavelInicio instanceof Literal && literalOuVariavelFim instanceof Literal) {
                 if (literalOuVariavelInicio.valor > literalOuVariavelFim.valor) {
                     passo = new Unario(
-                        this.hashArquivo, 
+                        this.hashArquivo,
                         new Simbolo(
-                            tiposDeSimbolos.SUBTRACAO, 
-                            '-', 
-                            undefined, 
-                            simboloPara.linha, 
+                            tiposDeSimbolos.SUBTRACAO,
+                            '-',
+                            undefined,
+                            simboloPara.linha,
                             simboloPara.hashArquivo
-                        ), 
+                        ),
                         new Literal(this.hashArquivo, Number(simboloPara.linha), 1),
                         "ANTES");
                     operadorCondicao = new Simbolo(tiposDeSimbolos.MAIOR_IGUAL, '', '', Number(simboloPara.linha), this.hashArquivo);
@@ -797,8 +797,8 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
                 literalOuVariavelFim
             ),
             new FimPara(
-                this.hashArquivo, 
-                Number(simboloPara.linha), 
+                this.hashArquivo,
+                Number(simboloPara.linha),
                 new Binario(
                     this.hashArquivo,
                     new Variavel(this.hashArquivo, variavelIteracao),
@@ -840,7 +840,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
 
             // Consumir parêntese direito
             this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO, 
+                tiposDeSimbolos.PARENTESE_DIREITO,
                 "Esperado parêntese direito para finalização da leitura de parâmetros."
             )
         }
@@ -854,7 +854,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
     declaracaoProcedimento() {
         const simboloProcedimento: SimboloInterface = this.avancarEDevolverAnterior();
 
-        const nomeProcedimento = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 
+        const nomeProcedimento = this.consumir(tiposDeSimbolos.IDENTIFICADOR,
             "Esperado nome do procedimento após palavra-chave `procedimento`.");
 
         // Parâmetros
@@ -867,11 +867,11 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             .concat(this.blocoEscopo());
 
         return new FuncaoDeclaracao(
-            nomeProcedimento, 
+            nomeProcedimento,
             new FuncaoConstruto(
-                this.hashArquivo, 
-                Number(simboloProcedimento.linha), 
-                parametros, 
+                this.hashArquivo,
+                Number(simboloProcedimento.linha),
+                parametros,
                 corpo.filter(d => d)
             )
         );
@@ -997,8 +997,8 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
      * - O primeiro símbolo é `algoritmo`, seguido por um identificador e
      * uma quebra de linha.
      * - Os próximos símbolo pode `var`, que pode ser seguido por uma série de
-     * declarações de variáveis e finalizado por uma quebra de linha, 
-     * ou ainda `funcao` ou `procedimento`, seguidos dos devidos símbolos que definem 
+     * declarações de variáveis e finalizado por uma quebra de linha,
+     * ou ainda `funcao` ou `procedimento`, seguidos dos devidos símbolos que definem
      * os blocos.
      * - O penúltimo símbolo é `inicio`, seguido por uma quebra de linha.
      * Pode haver ou não declarações dentro do bloco.
@@ -1021,7 +1021,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         }
 
         let declaracoes = [];
-        this.validarSegmentoAlgoritmo();        
+        this.validarSegmentoAlgoritmo();
 
         while (!this.estaNoFinal() && this.simbolos[this.atual].tipo !== tiposDeSimbolos.FIM_ALGORITMO) {
             const declaracao = this.declaracao();
diff --git a/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts b/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts
index d2f154e1..e098379f 100644
--- a/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts
@@ -13,6 +13,7 @@ export class MicroAvaliadorSintatico {
     simbolos: SimboloInterface[];
     erros: ErroAvaliadorSintatico[];
     atual: number;
+    linha: number;
 
     avancarEDevolverAnterior(): SimboloInterface {
         if (this.atual < this.simbolos.length) this.atual += 1;
@@ -58,7 +59,7 @@ export class MicroAvaliadorSintatico {
                 valores = [];
 
                 if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
-                    return new Dicionario(-1, Number(simboloAtual.linha), [], []);
+                    return new Dicionario(-1, Number(this.linha), [], []);
                 }
 
                 while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
@@ -74,7 +75,7 @@ export class MicroAvaliadorSintatico {
                     }
                 }
 
-                return new Dicionario(-1, Number(simboloAtual.linha), chaves, valores); */
+                return new Dicionario(-1, Number(this.linha), chaves, valores); */
 
             // TODO: Verificar se vamos usar isso.
             /* case tiposDeSimbolos.COLCHETE_ESQUERDO:
@@ -82,7 +83,7 @@ export class MicroAvaliadorSintatico {
                 valores = [];
 
                 if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
-                    return new Vetor(-1, Number(simboloAtual.linha), []);
+                    return new Vetor(-1, Number(this.linha), []);
                 }
 
                 while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
@@ -93,12 +94,12 @@ export class MicroAvaliadorSintatico {
                     }
                 }
 
-                return new Vetor(-1, Number(simboloAtual.linha), valores);
+                return new Vetor(-1, Number(this.linha), valores);
             */
 
             case tiposDeSimbolos.FALSO:
                 this.avancarEDevolverAnterior();
-                return new Literal(-1, Number(simboloAtual.linha), false);
+                return new Literal(-1, Number(this.linha), false);
 
             case tiposDeSimbolos.IDENTIFICADOR:
                 const simboloIdentificador: SimboloInterface = this.avancarEDevolverAnterior();
@@ -122,23 +123,23 @@ export class MicroAvaliadorSintatico {
 
             case tiposDeSimbolos.NULO:
                 this.avancarEDevolverAnterior();
-                return new Literal(-1, Number(simboloAtual.linha), null);
+                return new Literal(-1, Number(this.linha), null);
 
             case tiposDeSimbolos.NUMERO:
             case tiposDeSimbolos.TEXTO:
                 const simboloNumeroTexto: SimboloInterface = this.avancarEDevolverAnterior();
-                return new Literal(-1, Number(simboloNumeroTexto.linha), simboloNumeroTexto.literal);
+                return new Literal(-1, Number(this.linha), simboloNumeroTexto.literal);
 
             case tiposDeSimbolos.PARENTESE_ESQUERDO:
                 this.avancarEDevolverAnterior();
                 const expressao = this.ou();
                 this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
 
-                return new Agrupamento(-1, Number(simboloAtual.linha), expressao);
+                return new Agrupamento(-1, Number(this.linha), expressao);
 
             case tiposDeSimbolos.VERDADEIRO:
                 this.avancarEDevolverAnterior();
-                return new Literal(-1, Number(simboloAtual.linha), true);
+                return new Literal(-1, Number(this.linha), true);
         }
 
         throw this.erro(this.simbolos[this.atual], 'Esperado expressão.');
@@ -362,9 +363,10 @@ export class MicroAvaliadorSintatico {
         return this.ou();
     }
 
-    analisar(retornoLexador: RetornoLexador): RetornoAvaliadorSintatico {
+    analisar(retornoLexador: RetornoLexador, linha: number): RetornoAvaliadorSintatico {
         this.erros = [];
         this.atual = 0;
+        this.linha = linha;
 
         this.simbolos = retornoLexador?.simbolos || [];
 
diff --git a/fontes/construtos/atribuicao-sobrescrita.ts b/fontes/construtos/atribuicao-por-indice.ts
similarity index 79%
rename from fontes/construtos/atribuicao-sobrescrita.ts
rename to fontes/construtos/atribuicao-por-indice.ts
index a689ab3d..d7587980 100644
--- a/fontes/construtos/atribuicao-sobrescrita.ts
+++ b/fontes/construtos/atribuicao-por-indice.ts
@@ -1,7 +1,7 @@
 import { VisitanteComumInterface } from '../interfaces'
 import { Construto } from './construto';
 
-export class AtribuicaoSobrescrita implements Construto {
+export class AtribuicaoPorIndice implements Construto {
     linha: number;
     hashArquivo: number;
 
@@ -19,6 +19,6 @@ export class AtribuicaoSobrescrita implements Construto {
     }
 
     async aceitar(visitante: VisitanteComumInterface): Promise<any> {
-        return await visitante.visitarExpressaoAtribuicaoSobrescrita(this);
+        return await visitante.visitarExpressaoAtribuicaoPorIndice(this);
     }
 }
diff --git a/fontes/construtos/index.ts b/fontes/construtos/index.ts
index f23cb80d..5cfaf16d 100644
--- a/fontes/construtos/index.ts
+++ b/fontes/construtos/index.ts
@@ -1,4 +1,4 @@
-export * from './atribuicao-sobrescrita';
+export * from './atribuicao-por-indice';
 export * from './atribuir';
 export * from './binario';
 export * from './chamada';
diff --git a/fontes/construtos/literal.ts b/fontes/construtos/literal.ts
index 56974d59..447ba054 100644
--- a/fontes/construtos/literal.ts
+++ b/fontes/construtos/literal.ts
@@ -17,6 +17,6 @@ export class Literal implements Construto {
     }
 
     async aceitar(visitante: VisitanteComumInterface): Promise<any> {
-        return Promise.resolve(visitante.visitarExpressaoLiteral(this));
+        return await visitante.visitarExpressaoLiteral(this);
     }
 }
diff --git a/fontes/interfaces/resolvedor-interface.ts b/fontes/interfaces/resolvedor-interface.ts
index 28f1c6f6..84c5439a 100644
--- a/fontes/interfaces/resolvedor-interface.ts
+++ b/fontes/interfaces/resolvedor-interface.ts
@@ -34,7 +34,7 @@ export interface ResolvedorInterface {
     visitarExpressaoAcessoIndiceVariavel(expressao: any): any;
     visitarExpressaoContinua(declaracao?: any): any;
     visitarExpressaoSustar(declaracao?: any): any;
-    visitarExpressaoAtribuicaoSobrescrita(expressao?: any): any;
+    visitarExpressaoAtribuicaoPorIndice(expressao?: any): any;
     visitarExpressaoLiteral(expressao?: any): any;
     visitarExpressaoLogica(expressao?: any): any;
     visitarExpressaoUnaria(expressao?: any): any;
diff --git a/fontes/interfaces/visitante-comum-interface.ts b/fontes/interfaces/visitante-comum-interface.ts
index e54a0c3b..5b460b35 100644
--- a/fontes/interfaces/visitante-comum-interface.ts
+++ b/fontes/interfaces/visitante-comum-interface.ts
@@ -57,7 +57,7 @@ export interface VisitanteComumInterface {
     visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra;
     visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
     visitarExpressaoDeleguaFuncao(expressao: any): any;
-    visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any>;
+    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any>;
     visitarExpressaoAcessoIndiceVariavel(expressao: any): any;
     visitarExpressaoDefinirValor(expressao: any): any;
     visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): any;
@@ -67,4 +67,4 @@ export interface VisitanteComumInterface {
     visitarExpressaoDicionario(expressao: any): any;
     visitarExpressaoVetor(expressao: any): any;
     visitarExpressaoSuper(expressao: Super): any;
-}
\ No newline at end of file
+}
diff --git a/fontes/interpretador/dialetos/birl/interpretador-birl.ts b/fontes/interpretador/dialetos/birl/interpretador-birl.ts
index 61174fcd..6ccc0e94 100644
--- a/fontes/interpretador/dialetos/birl/interpretador-birl.ts
+++ b/fontes/interpretador/dialetos/birl/interpretador-birl.ts
@@ -1,4 +1,4 @@
-import { Construto, Atribuir, Literal, FimPara, FormatacaoEscrita, Super } from '../../../construtos';
+import { Construto, Atribuir, Literal, FimPara, FormatacaoEscrita, Super, Variavel, Unario } from '../../../construtos';
 import {
     Declaracao,
     Expressao,
@@ -25,13 +25,15 @@ import {
 import { EspacoVariaveis } from '../../../espaco-variaveis';
 import { ObjetoPadrao } from '../../../estruturas';
 import { ErroEmTempoDeExecucao } from '../../../excecoes';
-import { InterpretadorInterface } from '../../../interfaces';
+import { InterpretadorInterface, SimboloInterface, VariavelInterface } from '../../../interfaces';
 import { ErroInterpretador } from '../../../interfaces/erros/erro-interpretador';
 import { EscopoExecucao } from '../../../interfaces/escopo-execucao';
 import { PilhaEscoposExecucaoInterface } from '../../../interfaces/pilha-escopos-execucao-interface';
 import { RetornoInterpretador } from '../../../interfaces/retornos';
 import { ContinuarQuebra, SustarQuebra, RetornoQuebra, Quebra } from '../../../quebras';
+import { inferirTipoVariavel } from '../../inferenciador';
 import { PilhaEscoposExecucao } from '../../pilha-escopos-execucao';
+import tiposDeSimbolos from '../../../tipos-de-simbolos/birl';
 
 export class InterpretadorBirl implements InterpretadorInterface {
     diretorioBase: any;
@@ -65,10 +67,9 @@ export class InterpretadorBirl implements InterpretadorInterface {
             ambiente: new EspacoVariaveis(),
             finalizado: false,
             tipo: 'outro',
-            emLacoRepeticao: false
+            emLacoRepeticao: false,
         };
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-
     }
 
     async avaliar(expressao: Construto | Declaracao): Promise<any> {
@@ -80,19 +81,231 @@ export class InterpretadorBirl implements InterpretadorInterface {
             console.log('Aqui');
         } */
 
-        return await expressao.aceitar(this);
+        return await expressao. aceitar(this);
     }
-    executarBloco(declaracoes: Declaracao[], ambiente?: EspacoVariaveis): Promise<any> {
-        throw new Error('Método não implementado.');
+    /**
+     * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
+     * executa as declarações empilhadas.
+     * Se o retorno do último bloco foi uma exceção (normalmente um erro em tempo de execução),
+     * atira a exceção daqui.
+     * Isso é usado, por exemplo, em blocos tente ... pegue ... finalmente.
+     * @param declaracoes Um vetor de declaracoes a ser executado.
+     * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
+     */
+    async executarBloco(declaracoes: Declaracao[], ambiente?: EspacoVariaveis): Promise<any> {
+        const escopoExecucao: EscopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            ambiente: ambiente || new EspacoVariaveis(),
+            finalizado: false,
+            tipo: 'outro',
+            emLacoRepeticao: false,
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        const retornoUltimoEscopo: any = await this.executarUltimoEscopo();
+        if (retornoUltimoEscopo instanceof ErroEmTempoDeExecucao) {
+            return Promise.reject(retornoUltimoEscopo);
+        }
+        return retornoUltimoEscopo;
     }
     visitarExpressaoAgrupamento(expressao: any): Promise<any> {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoUnaria(expressao: any) {
-        throw new Error('Método não implementado.');
+
+    protected verificarOperandoNumero(operador: SimboloInterface, operando: any): void {
+        if (typeof operando === 'number' || operando.tipo === 'número') return;
+        throw new ErroEmTempoDeExecucao(operador, 'Operando precisa ser um número.', Number(operador.linha));
+    }
+
+    async visitarExpressaoUnaria(expressao: Unario): Promise<any> {
+        const operando = await this.avaliar(expressao.operando);
+        let valor: any = operando.hasOwnProperty('valor') ? operando.valor : operando;
+
+        switch (expressao.operador.tipo) {
+            case tiposDeSimbolos.SUBTRACAO:
+                this.verificarOperandoNumero(expressao.operador, valor);
+                return -valor;
+            case tiposDeSimbolos.NEGACAO:
+                return !this.eVerdadeiro(valor);
+            case tiposDeSimbolos.BIT_NOT:
+                return ~valor;
+            // Para incrementar e decrementar, primeiro precisamos saber se o operador
+            // veio antes do literal ou variável.
+            // Se veio antes e o operando é uma variável, precisamos incrementar/decrementar,
+            // armazenar o valor da variável pra só então devolver o valor.
+            case tiposDeSimbolos.INCREMENTAR:
+                if (expressao.incidenciaOperador === 'ANTES') {
+                    valor++;
+                    if (expressao.operando instanceof Variavel) {
+                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
+                    }
+
+                    return valor;
+                }
+
+                const valorAnteriorIncremento = valor;
+                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, ++valor);
+                return valorAnteriorIncremento;
+            case tiposDeSimbolos.DECREMENTAR:
+                if (expressao.incidenciaOperador === 'ANTES') {
+                    valor--;
+                    if (expressao.operando instanceof Variavel) {
+                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
+                    }
+
+                    return valor;
+                }
+
+                const valorAnteriorDecremento = valor;
+                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, --valor);
+                return valorAnteriorDecremento;
+        }
+
+        return null;
     }
-    visitarExpressaoBinaria(expressao: any) {
-        throw new Error('Método não implementado.');
+
+    protected eIgual(esquerda: VariavelInterface | any, direita: VariavelInterface | any): boolean {
+        if (esquerda === null && direita === null) return true;
+        if (esquerda === null) return false;
+        return esquerda === direita;
+    }
+
+    /**
+     * 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.
+     */
+    protected verificarOperandosNumeros(
+        operador: SimboloInterface,
+        direita: VariavelInterface | any,
+        esquerda: VariavelInterface | any
+    ): void {
+        const tipoDireita: string = direita.tipo ? direita.tipo : typeof direita === 'number' ? 'número' : String(NaN);
+        const tipoEsquerda: string = esquerda.tipo
+            ? esquerda.tipo
+            : typeof esquerda === 'number'
+            ? 'número'
+            : String(NaN);
+        if (tipoDireita === 'número' && tipoEsquerda === 'número') return;
+        throw new ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
+    }
+
+    async visitarExpressaoBinaria(expressao: any): Promise<any> {
+        try {
+            const esquerda: VariavelInterface | any = await this.avaliar(expressao.esquerda);
+            const direita: VariavelInterface | any = await this.avaliar(expressao.direita);
+            const valorEsquerdo: any = esquerda?.hasOwnProperty('valor') ? esquerda.valor : esquerda;
+            const valorDireito: any = direita?.hasOwnProperty('valor') ? direita.valor : direita;
+            const tipoEsquerdo: string = esquerda?.hasOwnProperty('tipo')
+                ? esquerda.tipo
+                : inferirTipoVariavel(esquerda);
+            const tipoDireito: string = direita?.hasOwnProperty('tipo') ? direita.tipo : inferirTipoVariavel(direita);
+
+            switch (expressao.operador.tipo) {
+                case tiposDeSimbolos.EXPONENCIACAO:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Math.pow(valorEsquerdo, valorDireito);
+
+                case tiposDeSimbolos.MAIOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) > Number(valorDireito);
+
+                case tiposDeSimbolos.MAIOR_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) >= Number(valorDireito);
+
+                case tiposDeSimbolos.MENOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) < Number(valorDireito);
+
+                case tiposDeSimbolos.MENOR_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) <= Number(valorDireito);
+
+                case tiposDeSimbolos.SUBTRACAO:
+                case tiposDeSimbolos.MENOS_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) - Number(valorDireito);
+
+                case tiposDeSimbolos.ADICAO:
+                case tiposDeSimbolos.MAIS_IGUAL:
+                    if (tipoEsquerdo === 'número' && tipoDireito === 'número') {
+                        return Number(valorEsquerdo) + Number(valorDireito);
+                    } else {
+                        return String(valorEsquerdo) + String(valorDireito);
+                    }
+
+                case tiposDeSimbolos.DIVISAO:
+                case tiposDeSimbolos.DIVISAO_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) / Number(valorDireito);
+
+                case tiposDeSimbolos.DIVISAO_INTEIRA:
+                case tiposDeSimbolos.DIVISAO_INTEIRA_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
+
+                case tiposDeSimbolos.MULTIPLICACAO:
+                case tiposDeSimbolos.MULTIPLICACAO_IGUAL:
+                    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') {
+                            return valorEsquerdo.repeat(Number(valorDireito));
+                        }
+
+                        return valorDireito.repeat(Number(valorEsquerdo));
+                    }
+
+                    return Number(valorEsquerdo) * Number(valorDireito);
+
+                case tiposDeSimbolos.MODULO:
+                case tiposDeSimbolos.MODULO_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) % Number(valorDireito);
+
+                case tiposDeSimbolos.BIT_AND:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) & Number(valorDireito);
+
+                case tiposDeSimbolos.BIT_XOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) ^ Number(valorDireito);
+
+                case tiposDeSimbolos.BIT_OR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) | Number(valorDireito);
+
+                case tiposDeSimbolos.MENOR_MENOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) << Number(valorDireito);
+
+                case tiposDeSimbolos.MAIOR_MAIOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) >> Number(valorDireito);
+
+                case tiposDeSimbolos.DIFERENTE:
+                    return !this.eIgual(valorEsquerdo, valorDireito);
+
+                case tiposDeSimbolos.IGUAL_IGUAL:
+                    return this.eIgual(valorEsquerdo, valorDireito);
+            }
+        } catch (erro: any) {
+            this.erros.push({
+                erroInterno: erro,
+                linha: expressao.linha,
+                hashArquivo: expressao.hashArquivo,
+            });
+            return Promise.reject(erro);
+        }
     }
     visitarExpressaoDeChamada(expressao: any) {
         throw new Error('Método não implementado.');
@@ -100,8 +313,13 @@ export class InterpretadorBirl implements InterpretadorInterface {
     visitarDeclaracaoDeAtribuicao(expressao: Atribuir) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoDeVariavel(expressao: any) {
-        throw new Error('Método não implementado.');
+
+    protected procurarVariavel(simbolo: SimboloInterface): any {
+        return this.pilhaEscoposExecucao.obterValorVariavel(simbolo);
+    }
+
+    visitarExpressaoDeVariavel(expressao: Variavel): any {
+        return this.procurarVariavel(expressao.simbolo);
     }
     visitarDeclaracaoDeExpressao(declaracao: Expressao) {
         throw new Error('Método não implementado.');
@@ -138,13 +356,13 @@ export class InterpretadorBirl implements InterpretadorInterface {
         });
     }
 
-     /**
+    /**
      * Retira a interpolação de um texto.
      * @param {texto} texto O texto
      * @param {any[]} variaveis A lista de variaveis interpoladas
      * @returns O texto com o valor das variaveis.
      */
-     private retirarInterpolacao(texto: string, variaveis: any[]): string {
+    private retirarInterpolacao(texto: string, variaveis: any[]): string {
         const valoresVariaveis = variaveis.map((v) => ({
             valorResolvido: this.pilhaEscoposExecucao.obterVariavelPorNome(v.variavel),
             variavel: v.variavel,
@@ -163,22 +381,58 @@ export class InterpretadorBirl implements InterpretadorInterface {
         return textoFinal;
     }
 
-
     visitarExpressaoLiteral(expressao: Literal): any {
-        if (this.regexInterpolacao.test(expressao.valor)) {
-            const variaveis = this.buscarVariaveisInterpolacao(expressao.valor);
-
-            return this.retirarInterpolacao(expressao.valor, variaveis);
+        if (expressao.valor === tiposDeSimbolos.ADICAO) {
+            return 1
+        } else if (expressao.valor === tiposDeSimbolos.SUBTRACAO) {
+            return -1
+        } else {
+            return expressao.valor;
         }
-
-        return expressao.valor;
     }
 
     visitarExpressaoLogica(expressao: any) {
         throw new Error('Método não implementado.');
     }
-    visitarDeclaracaoPara(declaracao: Para): Promise<any> {
-        throw new Error('Método não implementado.');
+    async visitarDeclaracaoPara(declaracao: Para): Promise<any> {
+        if (declaracao.inicializador !== null) {
+            if (declaracao.inicializador instanceof Array) {
+                await this.avaliar(declaracao.inicializador[0]);
+            } else {
+                await this.avaliar(declaracao.inicializador);
+            }
+        }
+
+        let retornoExecucao: any;
+        while (!(retornoExecucao instanceof Quebra)) {
+            if (declaracao.condicao !== null && !this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+                break;
+            }
+
+            try {
+                retornoExecucao = await this.executar(declaracao.corpo);
+                if (retornoExecucao instanceof SustarQuebra) {
+                    return null;
+                }
+
+                if (retornoExecucao instanceof ContinuarQuebra) {
+                    retornoExecucao = null;
+                }
+            } catch (erro: any) {
+                this.erros.push({
+                    erroInterno: erro,
+                    linha: declaracao.linha,
+                    hashArquivo: declaracao.hashArquivo,
+                });
+                return Promise.reject(erro);
+            }
+
+            if (declaracao.incrementar !== null) {
+                await this.avaliar(declaracao.incrementar);
+            }
+        }
+
+        return retornoExecucao;
     }
     visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
         throw new Error('Método não implementado.');
@@ -278,14 +532,14 @@ export class InterpretadorBirl implements InterpretadorInterface {
     visitarExpressaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
-        throw new Error('Método não implementado.');
+    async visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
+        return await this.executarBloco(declaracao.declaracoes);
     }
 
     protected async avaliacaoDeclaracaoVar(declaracao: Var): Promise<any> {
         let valorOuOutraVariavel = null;
         if (declaracao.inicializador !== null) {
-            valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
+            valorOuOutraVariavel = await this. avaliar(declaracao.inicializador);
         }
 
         let valorFinal = null;
@@ -334,7 +588,7 @@ export class InterpretadorBirl implements InterpretadorInterface {
     visitarExpressaoDeleguaFuncao(expressao: any) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any> {
+    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
         throw new Error('Método não implementado.');
     }
     visitarExpressaoAcessoIndiceVariavel(expressao: any) {
@@ -393,14 +647,23 @@ export class InterpretadorBirl implements InterpretadorInterface {
      *                         pelo modo LAIR.
      */
     async executar(declaracao: Declaracao, mostrarResultado = false): Promise<any> {
-        const resultado: any = await declaracao.aceitar(this);
-        if (mostrarResultado) {
-            this.funcaoDeRetorno(this.paraTexto(resultado));
-        }
-        if (resultado || typeof resultado === 'boolean') {
-            this.resultadoInterpretador.push(this.paraTexto(resultado));
+        let resultado: any = null;
+        // Tratar caso Bloco
+        if (declaracao instanceof Array) {
+            for (const decl of declaracao) {
+                resultado = await this.executar(decl, mostrarResultado);
+            }
+            return resultado;
+        } else {
+            resultado = await declaracao.aceitar(this);
+            if (mostrarResultado) {
+                this.funcaoDeRetorno(this.paraTexto(resultado));
+            }
+            if (resultado || typeof resultado === 'boolean') {
+                this.resultadoInterpretador.push(this.paraTexto(resultado));
+            }
+            return resultado;
         }
-        return resultado;
     }
 
     /**
diff --git a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
index ac8b18e6..8a326e25 100644
--- a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
+++ b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
@@ -86,15 +86,15 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
 
         carregarBibliotecaGlobal(this, this.pilhaEscoposExecucao);
     }
-    
+
     visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
         throw new Error('Método não implementado.');
     }
-    
+
     visitarDeclaracaoConst(declaracao: Const): Promise<any> {
         throw new Error('Método não implementado.');
     }
-    
+
     visitarExpressaoFimPara(declaracao: FimPara) {
         throw new Error('Método não implementado.');
     }
@@ -651,7 +651,7 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         return new DeleguaFuncao(null, expressao);
     }
 
-    async visitarExpressaoAtribuicaoSobrescrita(expressao: any) {
+    async visitarExpressaoAtribuicaoPorIndice(expressao: any) {
         const objeto = await this.avaliar(expressao.objeto);
         let indice = await this.avaliar(expressao.indice);
         const valor = await this.avaliar(expressao.valor);
diff --git a/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts b/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
index 12b79c15..8360f3f9 100644
--- a/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
+++ b/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
@@ -66,11 +66,11 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
     visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
         throw new Error('Método não implementado.');
     }
-    
+
     visitarDeclaracaoConst(declaracao: Const): Promise<any> {
         throw new Error('Método não implementado.');
     }
-    
+
     visitarExpressaoFimPara(declaracao: FimPara) {
         throw new Error('Método não implementado.');
     }
@@ -448,7 +448,7 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         return null;
     }
 
-    visitarExpressaoAtribuicaoSobrescrita(expressao?: any): any {
+    visitarExpressaoAtribuicaoPorIndice(expressao?: any): any {
         return null;
     }
 
diff --git a/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts b/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
index 4492790b..54847996 100644
--- a/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
+++ b/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
@@ -15,13 +15,13 @@ import tiposDeSimbolos from '../../../tipos-de-simbolos/portugol-ipt';
 import { inferirTipoVariavel } from "../../inferenciador";
 
 export class InterpretadorPortugolIpt
-    implements InterpretadorInterface 
+    implements InterpretadorInterface
 {
     diretorioBase: any;
 
     funcaoDeRetorno: Function = null;
     funcaoDeRetornoMesmaLinha: Function = null;
-    
+
     pilhaEscoposExecucao: PilhaEscoposExecucaoInterface;
     interfaceEntradaSaida: any;
 
@@ -70,7 +70,7 @@ export class InterpretadorPortugolIpt
         if (expressao === null || expressao === undefined) {
             console.log('Aqui');
         }
-        
+
         return await expressao.aceitar(this);
     }
 
@@ -164,19 +164,19 @@ export class InterpretadorPortugolIpt
                 case tiposDeSimbolos.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 
+                        // 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);    
-                        } 
-                        
+                            return Number(valorEsquerdo) * Number(valorDireito);
+                        }
+
                         if (tipoEsquerdo === 'texto') {
                             return valorEsquerdo.repeat(Number(valorDireito));
                         }
 
                         return valorDireito.repeat(Number(valorEsquerdo));
                     }
-                    
+
                     return Number(valorEsquerdo) * Number(valorDireito);
 
                 case tiposDeSimbolos.MODULO:
@@ -207,7 +207,7 @@ export class InterpretadorPortugolIpt
     visitarExpressaoDeVariavel(expressao: Variavel): any {
         return this.procurarVariavel(expressao.simbolo);
     }
-    
+
     visitarDeclaracaoDeExpressao(declaracao: Expressao) {
         throw new Error("Método não implementado");
     }
@@ -350,7 +350,7 @@ export class InterpretadorPortugolIpt
             });
         }
     }
-    
+
     executarBloco(declaracoes: Declaracao[], ambiente?: EspacoVariaveis): Promise<any> {
         throw new Error("Método não implementado");
     }
@@ -381,7 +381,7 @@ export class InterpretadorPortugolIpt
      */
     async visitarDeclaracaoVar(declaracao: Var): Promise<any> {
         const valorFinal = await this.avaliacaoDeclaracaoVar(declaracao);
-        
+
         let subtipo;
         if (declaracao.tipo !== undefined) {
             subtipo = declaracao.tipo;
@@ -407,7 +407,7 @@ export class InterpretadorPortugolIpt
     visitarExpressaoDeleguaFuncao(expressao: any) {
         throw new Error("Método não implementado");
     }
-    visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any> {
+    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
         throw new Error("Método não implementado");
     }
     visitarExpressaoAcessoIndiceVariavel(expressao: any) {
@@ -437,7 +437,7 @@ export class InterpretadorPortugolIpt
     visitarExpressaoSuper(expressao: Super) {
         throw new Error("Método não implementado");
     }
-    
+
     paraTexto(objeto: any) {
         if (objeto === null || objeto === undefined) return 'nulo';
         if (typeof objeto === 'boolean') {
@@ -543,4 +543,4 @@ export class InterpretadorPortugolIpt
             return retorno;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/fontes/interpretador/inferenciador.ts b/fontes/interpretador/inferenciador.ts
index d78c241d..51a8ef38 100644
--- a/fontes/interpretador/inferenciador.ts
+++ b/fontes/interpretador/inferenciador.ts
@@ -1,4 +1,3 @@
-import { DeleguaModulo } from '../estruturas';
 
 export function inferirTipoVariavel(variavel: string | number | Array<any> | boolean | null | undefined) {
     const tipo = typeof variavel;
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index 2cbc5f19..f56237df 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -3,6 +3,9 @@ import hrtime from 'browser-process-hrtime';
 import { EspacoVariaveis } from '../espaco-variaveis';
 import carregarBibliotecasGlobais from '../bibliotecas/biblioteca-global';
 
+import { MicroLexador } from './../../fontes/lexador/micro-lexador';
+import { MicroAvaliadorSintatico } from './../../fontes/avaliador-sintatico/micro-avaliador-sintatico';
+
 import { ErroEmTempoDeExecucao } from '../excecoes';
 import { InterpretadorInterface, ParametroInterface, SimboloInterface, VariavelInterface } from '../interfaces';
 import {
@@ -81,8 +84,10 @@ export class InterpretadorBase implements InterpretadorInterface {
     declaracoes: Declaracao[];
     pilhaEscoposExecucao: PilhaEscoposExecucaoInterface;
     interfaceEntradaSaida: any = null;
+    microLexador: MicroLexador = new MicroLexador();
+    microAvaliadorSintatico: MicroAvaliadorSintatico = new MicroAvaliadorSintatico();
 
-    regexInterpolacao = /\$\{([a-z_][\w]*)\}/gi;
+    regexInterpolacao = /\$\{([a-z_0-9][\w \.\,\+\-\(\)\*\/\^]*)\}/gi;
 
     constructor(
         diretorioBase: string,
@@ -149,23 +154,14 @@ export class InterpretadorBase implements InterpretadorInterface {
      * @param {any[]} variaveis A lista de variaveis interpoladas
      * @returns O texto com o valor das variaveis.
      */
-    private retirarInterpolacao(texto: string, variaveis: any[]): string {
-        const valoresVariaveis = variaveis.map((v) => ({
-            valorResolvido: this.pilhaEscoposExecucao.obterVariavelPorNome(v.variavel),
-            variavel: v.variavel,
-        }));
-
+    private async retirarInterpolacao(texto: string, variaveis: any[]): Promise<string> {
         let textoFinal = texto;
-
-        valoresVariaveis.forEach((elemento) => {
-            const valorFinal = elemento.valorResolvido.hasOwnProperty('valor')
-                ? elemento.valorResolvido.valor
-                : elemento.valorResolvido;
-
-            textoFinal = textoFinal.replace('${' + elemento.variavel + '}', valorFinal);
+        variaveis.forEach((elemento) => {
+            textoFinal = textoFinal.replace('${' + elemento.variavel + '}', elemento.valor)
         });
 
         return textoFinal;
+
     }
 
     /**
@@ -173,21 +169,38 @@ export class InterpretadorBase implements InterpretadorInterface {
      * @param {texto} textoOriginal O texto original com as variáveis interpoladas.
      * @returns Uma lista de variáveis interpoladas.
      */
-    private buscarVariaveisInterpolacao(textoOriginal: string): any[] {
+    private async buscarVariaveisInterpolacao(textoOriginal: string, linha: number): Promise<any[]> {
         const variaveis = textoOriginal.match(this.regexInterpolacao);
 
-        return variaveis.map((s) => {
-            const nomeVariavel: string = s.replace(/[\$\{\}]*/g, '');
+        let resultadosAvaliacaoSintatica = variaveis.map((s) => {
+            const nomeVariavel: string = s.replace(/[\$\{\}]*/gm, '');
+
+            let microLexador = this.microLexador.mapear(nomeVariavel);
+            const resultadoMicroAvaliadorSintatico = this.microAvaliadorSintatico.analisar(microLexador, linha);
+
             return {
-                variavel: nomeVariavel,
-                valor: this.pilhaEscoposExecucao.obterVariavelPorNome(nomeVariavel),
+                nomeVariavel,
+                resultadoMicroAvaliadorSintatico
             };
         });
+
+        //TODO verificar erros do resultadosAvaliacaoSintatica
+
+        const resolucoesPromises = await Promise.all(resultadosAvaliacaoSintatica.flatMap(r => r.resultadoMicroAvaliadorSintatico.declaracoes).map(d => {
+            return this.avaliar(d)
+        }))
+
+        return resolucoesPromises.map((item, indice) => {
+            return {
+                variavel: resultadosAvaliacaoSintatica[indice].nomeVariavel,
+                valor: item,
+            }
+        });
     }
 
-    visitarExpressaoLiteral(expressao: Literal): any {
+    async visitarExpressaoLiteral(expressao: Literal): Promise<any> {
         if (this.regexInterpolacao.test(expressao.valor)) {
-            const variaveis = this.buscarVariaveisInterpolacao(expressao.valor);
+            const variaveis = await this.buscarVariaveisInterpolacao(expressao.valor, expressao.linha);
 
             return this.retirarInterpolacao(expressao.valor, variaveis);
         }
@@ -1001,7 +1014,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         return new DeleguaFuncao(null, declaracao);
     }
 
-    async visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any> {
+    async visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
         const promises = await Promise.all([
             this.avaliar(expressao.objeto),
             this.avaliar(expressao.indice),
diff --git a/fontes/lexador/dialetos/lexador-birl.ts b/fontes/lexador/dialetos/lexador-birl.ts
index 3651db5e..8df8d66c 100644
--- a/fontes/lexador/dialetos/lexador-birl.ts
+++ b/fontes/lexador/dialetos/lexador-birl.ts
@@ -123,10 +123,22 @@ export class LexadorBirl extends LexadorBaseLinhaUnica {
                 this.avancar();
                 break;
             case '+':
+                if (this.proximoSimbolo() === '+') {
+                    this.avancar();
+                    this.avancar();
+                    this.adicionarSimbolo(tiposDeSimbolos.INCREMENTAR);
+                    break;
+                }
                 this.adicionarSimbolo(tiposDeSimbolos.ADICAO);
                 this.avancar();
                 break;
             case '-':
+                if (this.proximoSimbolo() === '-') {
+                    this.avancar();
+                    this.avancar();
+                    this.adicionarSimbolo(tiposDeSimbolos.DECREMENTAR);
+                    break;
+                }
                 this.adicionarSimbolo(tiposDeSimbolos.SUBTRACAO);
                 this.avancar();
                 break;
diff --git a/fontes/lexador/micro-lexador.ts b/fontes/lexador/micro-lexador.ts
index 76987e83..b86a81f8 100644
--- a/fontes/lexador/micro-lexador.ts
+++ b/fontes/lexador/micro-lexador.ts
@@ -63,11 +63,33 @@ export class MicroLexador {
         return this.eDigito(caractere) || this.eAlfabeto(caractere);
     }
 
+    eFinalDoCodigo(): boolean {
+        return this.codigo.length <= this.atual;
+    }
+
     adicionarSimbolo(tipo: string, literal: any = null): void {
         const texto: string = this.codigo.substring(this.inicioSimbolo, this.atual);
         this.simbolos.push(new Simbolo(tipo, literal || texto, literal, 1, -1));
     }
 
+    analisarTexto(delimitador = '"'): void {
+        while (this.codigo[this.atual] !== delimitador && !this.eFinalDoCodigo()) {
+            this.atual++;
+        }
+
+        if (this.eFinalDoCodigo()) {
+            this.erros.push({
+                linha: 1,
+                caractere: this.codigo[this.atual - 1],
+                mensagem: 'Texto não finalizado.',
+            } as ErroLexador);
+            return;
+        }
+
+        const valor = this.codigo.substring(this.inicioSimbolo + 1, this.atual);
+        this.adicionarSimbolo(tiposDeSimbolos.TEXTO, valor);
+    }
+
     analisarNumero(): void {
         while (this.eDigito(this.codigo[this.atual])) {
             this.atual++;
@@ -86,24 +108,6 @@ export class MicroLexador {
         this.adicionarSimbolo(tiposDeSimbolos.NUMERO, parseFloat(numeroCompleto));
     }
 
-    analisarTexto(delimitador = '"'): void {
-        while (this.codigo[this.atual] !== delimitador && this.atual < this.codigo.length) {
-            this.atual++;
-        }
-
-        if (this.atual >= this.codigo.length) {
-            this.erros.push({
-                linha: 1,
-                caractere: this.codigo[this.atual - 1],
-                mensagem: 'Texto não finalizado.',
-            } as ErroLexador);
-            return;
-        }
-
-        const valor = this.codigo.substring(this.inicioSimbolo + 1, this.atual);
-        this.adicionarSimbolo(tiposDeSimbolos.TEXTO, valor);
-    }
-
     identificarPalavraChave(): void {
         while (this.eAlfabetoOuDigito(this.codigo[this.atual])) {
             this.atual++;
@@ -120,8 +124,19 @@ export class MicroLexador {
         const caractere = this.codigo[this.atual];
 
         switch (caractere) {
+            case '(':
+                this.adicionarSimbolo(tiposDeSimbolos.PARENTESE_ESQUERDO);
+                this.atual++;
+                break;
+            case ')':
+                this.adicionarSimbolo(tiposDeSimbolos.PARENTESE_DIREITO);
+                this.atual++;
+                break;
+            case ',':
+                this.adicionarSimbolo(tiposDeSimbolos.VIRGULA);
+                this.atual++;
+                break;
             case '+':
-                this.inicioSimbolo = this.atual;
                 this.atual++;
                 if (this.codigo[this.atual] === '+') {
                     this.adicionarSimbolo(tiposDeSimbolos.INCREMENTAR);
@@ -132,7 +147,6 @@ export class MicroLexador {
 
                 break;
             case '-':
-                this.inicioSimbolo = this.atual;
                 this.atual++;
                 if (this.codigo[this.atual] === '-') {
                     this.adicionarSimbolo(tiposDeSimbolos.DECREMENTAR);
@@ -143,7 +157,6 @@ export class MicroLexador {
 
                 break;
             case '*':
-                this.inicioSimbolo = this.atual;
                 this.atual++;
                 switch (this.codigo[this.atual]) {
                     case '*':
@@ -157,17 +170,14 @@ export class MicroLexador {
 
                 break;
             case '/':
-                this.inicioSimbolo = this.atual;
                 this.atual++;
                 this.adicionarSimbolo(tiposDeSimbolos.DIVISAO);
                 break;
             case '%':
-                this.inicioSimbolo = this.atual;
                 this.atual++;
                 this.adicionarSimbolo(tiposDeSimbolos.MODULO);
                 break;
             case '\\':
-                this.inicioSimbolo = this.atual;
                 this.atual++;
                 this.adicionarSimbolo(tiposDeSimbolos.DIVISAO_INTEIRA);
                 break;
@@ -213,7 +223,8 @@ export class MicroLexador {
         this.atual = 0;
         this.inicioSimbolo = 0;
 
-        while (this.atual < codigo.length) {
+        while (!this.eFinalDoCodigo()) {
+            this.inicioSimbolo = this.atual;
             this.analisarToken();
         }
 
diff --git a/fontes/tipos-de-simbolos/birl.ts b/fontes/tipos-de-simbolos/birl.ts
index 05d3f6b5..89351c34 100644
--- a/fontes/tipos-de-simbolos/birl.ts
+++ b/fontes/tipos-de-simbolos/birl.ts
@@ -7,15 +7,25 @@ export default {
     BIRL: 'BIRL',
     BORA: 'BORA',
     BICEPS: 'BICEPS',
+    BIT_AND: 'BIT_AND',
+    BIT_XOR: 'BIT_XOR',
+    BIT_NOT: 'BIT_NOT',
+    BIT_OR: 'BIT_OR',
     CE: 'CE',
     CUMPADE: 'CUMPADE',
     DA: 'DA',
     DAR: 'DAR',
     DO: 'DO',
     DOENTE: 'DOENTE',
+    DIVISAO_IGUAL: 'DIVISAO_IGUAL',
+    DIVISAO_INTEIRA: 'DIVISAO_INTEIRA',
+    DIFERENTE: 'DIFERENTE',
+    DIVISAO_INTEIRA_IGUAL: 'DIVISAO_INTEIRA_IGUAL',
     DESCENDENTE: 'DESCENDENTE',
+    DECREMENTAR: 'DECREMENTAR',
     ELE: 'ELE',
     ESSA: 'ESSA',
+    EXPONENCIACAO:'EXPONENCIACAO',
     FRANGAO: 'FRANGAO',
     FRANGÃO: 'FRANGÃO',
     FRANGO: 'FRANGO',
@@ -23,20 +33,26 @@ export default {
     GENTE: 'GENTE',
     HOME: 'HOME',
     HORA: 'HORA',
+    INCREMENTAR: 'INCREMENTAR',
     MAIS: 'MAIS',
     MALUCO: 'MALUCO',
+    MENOR_MENOR: 'MENOR_MENOR',
+    MAIOR_MAIOR: 'MAIOR_MAIOR',
+    MENOS_IGUAL: 'MENOS_IGUAL',
+    MAIS_IGUAL: 'MAIS_IGUAL',
     MONSTRAO: 'MONSTRAO',
     MONSTRO: 'MONSTRO',
+    MODULO_IGUAL: 'MODULO_IGUAL',
+    MULTIPLICACAO_IGUAL: 'MULTIPLICACAO_IGUAL',
     MONSTRINHO: 'MONSTRINHO',
     TRAPEZIO: 'TRAPEZIO',
     NAO: 'NAO',
     NEGATIVA: 'NEGATIVA',
-    NEGATIVO: 'NEGATIVO',
+    NEGACAO: 'NEGACAO',
     O: 'O',
     OH: 'OH',
     PO: 'PO',
     PORRA: 'PORRA',
-    POSITIVO: 'POSITIVO',
     PUTA: 'PUTA',
     QUE: 'QUE',
     QUER: 'QUER',
diff --git a/fontes/tradutores/tradutor-javascript.ts b/fontes/tradutores/tradutor-javascript.ts
index 61b2d24c..41cc57f7 100644
--- a/fontes/tradutores/tradutor-javascript.ts
+++ b/fontes/tradutores/tradutor-javascript.ts
@@ -2,7 +2,7 @@ import {
     AcessoIndiceVariavel,
     AcessoMetodo,
     Agrupamento,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -371,7 +371,7 @@ export class TradutorJavaScript implements TradutorInterface {
     }
 
     traduzirDeclaracaoParaCada(declaracaoParaCada: ParaCada): string {
-        let resultado = `for (let ${declaracaoParaCada.nomeVariavelIteracao} of `; 
+        let resultado = `for (let ${declaracaoParaCada.nomeVariavelIteracao} of `;
         resultado +=
             this.dicionarioConstrutos[declaracaoParaCada.vetor.constructor.name](declaracaoParaCada.vetor) + ") ";
 
@@ -548,20 +548,20 @@ export class TradutorJavaScript implements TradutorInterface {
         return `${direita} ${operador} ${esquerda}`;
     }
 
-    traduzirConstrutoAtribuicaoSobrescrita(atribuicaoSobrescrita: AtribuicaoSobrescrita): string {
+    traduzirConstrutoAtribuicaoPorIndice(AtribuicaoPorIndice: AtribuicaoPorIndice): string {
         let resultado = '';
 
-        resultado += atribuicaoSobrescrita.objeto.simbolo.lexema + '[';
+        resultado += AtribuicaoPorIndice.objeto.simbolo.lexema + '[';
         resultado +=
-            this.dicionarioConstrutos[atribuicaoSobrescrita.indice.constructor.name](atribuicaoSobrescrita.indice) +
+            this.dicionarioConstrutos[AtribuicaoPorIndice.indice.constructor.name](AtribuicaoPorIndice.indice) +
             ']';
         resultado += ' = ';
 
-        if (atribuicaoSobrescrita?.valor?.simbolo?.lexema) {
-            resultado += `${atribuicaoSobrescrita.valor.simbolo.lexema}`;
+        if (AtribuicaoPorIndice?.valor?.simbolo?.lexema) {
+            resultado += `${AtribuicaoPorIndice.valor.simbolo.lexema}`;
         } else {
-            resultado += this.dicionarioConstrutos[atribuicaoSobrescrita.valor.constructor.name](
-                atribuicaoSobrescrita.valor
+            resultado += this.dicionarioConstrutos[AtribuicaoPorIndice.valor.constructor.name](
+                AtribuicaoPorIndice.valor
             );
         }
 
@@ -616,7 +616,7 @@ export class TradutorJavaScript implements TradutorInterface {
         AcessoIndiceVariavel: this.traduzirAcessoIndiceVariavel.bind(this),
         AcessoMetodo: this.trazudirConstrutoAcessoMetodo.bind(this),
         Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
-        AtribuicaoSobrescrita: this.traduzirConstrutoAtribuicaoSobrescrita.bind(this),
+        AtribuicaoPorIndice: this.traduzirConstrutoAtribuicaoPorIndice.bind(this),
         Atribuir: this.traduzirConstrutoAtribuir.bind(this),
         Binario: this.traduzirConstrutoBinario.bind(this),
         Chamada: this.traduzirConstrutoChamada.bind(this),
diff --git a/fontes/tradutores/tradutor-visualg.ts b/fontes/tradutores/tradutor-visualg.ts
index cf8436c8..c2bbc657 100644
--- a/fontes/tradutores/tradutor-visualg.ts
+++ b/fontes/tradutores/tradutor-visualg.ts
@@ -414,20 +414,20 @@ export class TradutorVisualg {
         return `${direita} ${operador} ${esquerda}`;
     }
 
-    // traduzirConstrutoAtribuicaoSobrescrita(atribuicaoSobrescrita: AtribuicaoSobrescrita): string {
+    // traduzirConstrutoAtribuicaoPorIndice(AtribuicaoPorIndice: AtribuicaoPorIndice): string {
     //     let resultado = '';
 
-    //     resultado += atribuicaoSobrescrita.objeto.simbolo.lexema + '[';
+    //     resultado += AtribuicaoPorIndice.objeto.simbolo.lexema + '[';
     //     resultado +=
-    //         this.dicionarioConstrutos[atribuicaoSobrescrita.indice.constructor.name](atribuicaoSobrescrita.indice) +
+    //         this.dicionarioConstrutos[AtribuicaoPorIndice.indice.constructor.name](AtribuicaoPorIndice.indice) +
     //         ']';
     //     resultado += ' = ';
 
-    //     if (atribuicaoSobrescrita?.valor?.simbolo?.lexema) {
-    //         resultado += `${atribuicaoSobrescrita.valor.simbolo.lexema}`;
+    //     if (AtribuicaoPorIndice?.valor?.simbolo?.lexema) {
+    //         resultado += `${AtribuicaoPorIndice.valor.simbolo.lexema}`;
     //     } else {
-    //         resultado += this.dicionarioConstrutos[atribuicaoSobrescrita.valor.constructor.name](
-    //             atribuicaoSobrescrita.valor
+    //         resultado += this.dicionarioConstrutos[AtribuicaoPorIndice.valor.constructor.name](
+    //             AtribuicaoPorIndice.valor
     //         );
     //     }
 
@@ -477,7 +477,7 @@ export class TradutorVisualg {
         // AcessoIndiceVariavel: this.traduzirAcessoIndiceVariavel.bind(this),
         // AcessoMetodo: this.trazudirConstrutoAcessoMetodo.bind(this),
         Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
-        // AtribuicaoSobrescrita: this.traduzirConstrutoAtribuicaoSobrescrita.bind(this),
+        // AtribuicaoPorIndice: this.traduzirConstrutoAtribuicaoPorIndice.bind(this),
         Binario: this.traduzirConstrutoBinario.bind(this),
         // Chamada: this.traduzirConstrutoChamada.bind(this),
         FimPara: this.traduzirConstrutoFimPara.bind(this),


Test patch:
diff --git a/testes/birl/avaliador-sintatico.test.ts b/testes/birl/avaliador-sintatico.test.ts
index dd0b8aac..ba1a030c 100644
--- a/testes/birl/avaliador-sintatico.test.ts
+++ b/testes/birl/avaliador-sintatico.test.ts
@@ -70,7 +70,6 @@ describe('Avaliador Sintático Birl', () => {
                     '   BORA CUMPADE 0; \n',
                     'BIRL \n',
                 ]);
-                //  FRANGO esta vindo como um indentificador
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                 expect(retornoAvaliadorSintatico).toBeTruthy();
@@ -94,6 +93,7 @@ describe('Avaliador Sintático Birl', () => {
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
             });
+
             it('Sucesso - Variavel - short int', () => {
                 const retornoLexador = lexador.mapear([
                     'HORA DO SHOW \n',
@@ -143,7 +143,7 @@ describe('Avaliador Sintático Birl', () => {
                 const retornoLexador = lexador.mapear([
                     'HORA DO SHOW \n',
                     `  BICEPS FRANGO TD = 'test'; \n`,
-                    '  CE QUER VER ESSA PORRA? (M1); \n',
+                    '  CE QUER VER ESSA PORRA? (TD); \n',
                     '  BORA CUMPADE 0; \n',
                     'BIRL \n',
                 ]);
@@ -152,6 +152,7 @@ describe('Avaliador Sintático Birl', () => {
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
             });
+
             it('Sucesso - declaração - if', () => {
                 const retornoLexador = lexador.mapear([
                     'HORA DO SHOW \n',
@@ -167,6 +168,7 @@ describe('Avaliador Sintático Birl', () => {
                 expect(retornoAvaliadorSintatico.declaracoes[0].assinaturaMetodo).toBe('<principal>');
                 expect(retornoAvaliadorSintatico.declaracoes[0]).toBeInstanceOf(Se);
             });
+
             it('Sucesso - declaração - if else', () => {
                 const retornoLexador = lexador.mapear([
                     'HORA DO SHOW \n',
@@ -236,6 +238,26 @@ describe('Avaliador Sintático Birl', () => {
                 expect(declaracao1.simbolo.lexema).toBe('M');
                 expect((retornoAvaliadorSintatico.declaracoes[1] as Para).corpo.declaracoes[0]).toBeInstanceOf(Escreva);
             });
+            it('Sucesso - declaração - for - incremento - atribuição', () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   MONSTRO M;\n',
+                    '   MAIS QUERO MAIS (M = 5; M > 0; ++M)',
+                    '       CE QUER VER ESSA PORRA? ("teste");\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
+                expect(retornoAvaliadorSintatico.declaracoes[1].assinaturaMetodo).toBe('<principal>');
+                expect(retornoAvaliadorSintatico.declaracoes[1]).toBeInstanceOf(Para);
+                const declaracao1 = retornoAvaliadorSintatico.declaracoes[0][0] as Var;
+                expect(declaracao1.inicializador.valor).toBe(0);
+                expect(declaracao1.simbolo.lexema).toBe('M');
+                expect((retornoAvaliadorSintatico.declaracoes[1] as Para).corpo.declaracoes[0]).toBeInstanceOf(Escreva);
+            });
             it('Sucesso - declaração - while', () => {
                 const RetornoLexador = lexador.mapear([
                     'HORA DO SHOW \n',
@@ -269,9 +291,6 @@ describe('Avaliador Sintático Birl', () => {
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
                 expect(retornoAvaliadorSintatico.declaracoes[1].assinaturaMetodo).toBe('<principal>');
                 expect(retornoAvaliadorSintatico.declaracoes[1]).toBeInstanceOf(Para);
-                const declaracao1 = retornoAvaliadorSintatico.declaracoes[1] as Para;
-                expect(declaracao1.corpo.declaracoes[0]).toBeInstanceOf(Escreva);
-                expect(declaracao1.corpo.declaracoes[1]).toBeInstanceOf(Sustar);
             });
             it('Sucesso - declaração - continue', () => {
                 const retornoLexador = lexador.mapear([
@@ -293,12 +312,6 @@ describe('Avaliador Sintático Birl', () => {
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
                 expect(retornoAvaliadorSintatico.declaracoes[1].assinaturaMetodo).toBe('<principal>');
                 expect(retornoAvaliadorSintatico.declaracoes[1]).toBeInstanceOf(Para);
-                const declaracao1 = retornoAvaliadorSintatico.declaracoes[1] as Para;
-                expect(declaracao1.corpo.declaracoes[0]).toBeInstanceOf(Escreva);
-                expect(declaracao1.corpo.declaracoes[1]).toBeInstanceOf(Se);
-                const declaracaoSe = declaracao1.corpo.declaracoes[1] as Se;
-                expect((declaracaoSe.caminhoEntao as Bloco).declaracoes[0]).toBeInstanceOf(Sustar);
-                expect((declaracaoSe.caminhoSenao as Bloco).declaracoes[0]).toBeInstanceOf(Continua);
             });
             it('Sucesso - declaração - declaracaoFuncao', () => {
                 const retornoLexador = lexador.mapear([
diff --git a/testes/birl/interpretador.test.ts b/testes/birl/interpretador.test.ts
index d2480380..d30295ff 100644
--- a/testes/birl/interpretador.test.ts
+++ b/testes/birl/interpretador.test.ts
@@ -15,6 +15,104 @@ describe('Interpretador', () => {
                 interpretador = new InterpretadorBirl(process.cwd());
             });
 
+            it('Sucesso - declaração - for - decremento - depois', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   MAIS QUERO MAIS (MONSTRO M = 6; M > 5; M--)',
+                    '       CE QUER VER ESSA PORRA? ("teste");\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - declaração - for - decremento - antes', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   MAIS QUERO MAIS (MONSTRO M = 10; M > 5; --M)',
+                    '       CE QUER VER ESSA PORRA? (M);\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - declaração - for - incremento - depois', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   MAIS QUERO MAIS (MONSTRO M = 0; M < 5; M++)',
+                    '       CE QUER VER ESSA PORRA? (M);\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - declaração - for - incremento - antes', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   MAIS QUERO MAIS (MONSTRO M = 0; M < 5; ++M)',
+                    '       CE QUER VER ESSA PORRA? (M);\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - declaração - if else', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   ELE QUE A GENTE QUER? (1 > 2)\n',
+                    '     CE QUER VER ESSA PORRA? ("teste1");\n',
+                    '   NAO VAI DAR NAO\n',
+                    '     CE QUER VER ESSA PORRA? ("teste");\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - declaração - if', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   ELE QUE A GENTE QUER? (3 > 2)\n',
+                    '     CE QUER VER ESSA PORRA? ("teste");\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
             it('Sucesso - Hello, World! Porra!', async () => {
                 const retornoLexador = lexador.mapear(
                     [
@@ -32,6 +130,109 @@ describe('Interpretador', () => {
 
                 expect(retornoInterpretador.erros).toHaveLength(0);
             });
+
+            it('Sucesso - Variavel - Numero', async () => {
+                const retornoLexador = lexador.mapear(
+                    [
+                        'HORA DO SHOW \n',
+                        '  MONSTRO M1 = 1; \n',
+                        '  CE QUER VER ESSA PORRA? (M1); \n',
+                        '  BORA CUMPADE 0; \n',
+                        'BIRL \n',
+                    ],
+                    -1
+                );
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            })
+
+            it('Sucesso - Variavel - String', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    "   FRANGO FR = 'testes';\n",
+                    '   CE QUER VER ESSA PORRA? (FR); \n',
+                    '   BORA CUMPADE 0; \n',
+                    'BIRL \n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - Variavel - Float', async () => {
+                const retornoLexador = lexador.mapear(
+                    [
+                        'HORA DO SHOW \n',
+                        '  TRAPEZIO M1 = 1.03; \n',
+                        '  CE QUER VER ESSA PORRA? (M1); \n',
+                        '  BORA CUMPADE 0; \n',
+                        'BIRL \n',
+                    ],
+                    -1
+                );
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - Variavel - short int', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '  MONSTRINHO M1 = 1.03; \n',
+                    '  CE QUER VER ESSA PORRA? (M1); \n',
+                    '  BORA CUMPADE 0; \n',
+                    'BIRL \n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - Variavel - long int', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '  MONSTRAO M1 = 16666666; \n',
+                    '  CE QUER VER ESSA PORRA? (M1); \n',
+                    '  BORA CUMPADE 0; \n',
+                    'BIRL \n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - Variavel - double', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '  TRAPEZIO DESCENDENTE TD = 0.37; \n',
+                    '  CE QUER VER ESSA PORRA? (TD); \n',
+                    '  BORA CUMPADE 0; \n',
+                    'BIRL \n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
         });
     });
 });
diff --git a/testes/birl/lexador.test.ts b/testes/birl/lexador.test.ts
index 93c7195a..ff108d24 100644
--- a/testes/birl/lexador.test.ts
+++ b/testes/birl/lexador.test.ts
@@ -86,7 +86,7 @@ describe('Lexador (BIRL)', () => {
                 );
 
                 expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(51);
+                expect(resultado.simbolos).toHaveLength(50);
                 expect(resultado.erros).toHaveLength(0);
             });
             it('Sucesso - Loop - While', () => {
@@ -105,7 +105,7 @@ describe('Lexador (BIRL)', () => {
                 );
 
                 expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(49);
+                expect(resultado.simbolos).toHaveLength(48);
                 expect(resultado.erros).toHaveLength(0);
             });
             it('Sucesso - Condição - If', () => {
@@ -182,7 +182,7 @@ describe('Lexador (BIRL)', () => {
                 );
 
                 expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(62);
+                expect(resultado.simbolos).toHaveLength(61);
                 expect(resultado.erros).toHaveLength(0);
             });
             it('Sucesso - Declaração de Função', () => {
diff --git a/testes/interpretador.test.ts b/testes/interpretador.test.ts
index 9b46059d..ff80cb20 100644
--- a/testes/interpretador.test.ts
+++ b/testes/interpretador.test.ts
@@ -81,6 +81,22 @@ describe('Interpretador', () => {
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
+                it('Interpolação de Texto/Função/Expressão', async () => {
+                    const retornoLexador = lexador.mapear([
+                        "funcao somar(num1, num2) {",
+                        "retorna num1 + num2;",
+                        "}",
+                        "escreva('somar: ${somar(5, 3)} = ${4 + 5 - 1}');",
+                        "escreva('somar com ponto flutuante: ${somar(5.7, 3.3)} = ${5 + 5 - 1}');",
+                        "escreva('${4 - 2 / 1}');",
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                });
+
                 it('Incremento e decremento após variável ou literal', async () => {
                     const retornoLexador = lexador.mapear([
                         'var a = 1',
diff --git a/testes/micro-avaliador-sintatico.test.ts b/testes/micro-avaliador-sintatico.test.ts
index 60be3462..41a6c1f1 100644
--- a/testes/micro-avaliador-sintatico.test.ts
+++ b/testes/micro-avaliador-sintatico.test.ts
@@ -13,7 +13,7 @@ describe('Avaliador sintático', () => {
 
         it('Sucesso - Texto Vazio', () => {
             const retornoLexador = microLexador.mapear("");
-            const retornoAvaliadorSintatico = microAvaliadorSintatico.analisar(retornoLexador);
+            const retornoAvaliadorSintatico = microAvaliadorSintatico.analisar(retornoLexador, 1);
 
             expect(retornoAvaliadorSintatico).toBeTruthy();
             expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
@@ -21,7 +21,15 @@ describe('Avaliador sintático', () => {
 
         it('Sucesso - Olá Mundo', () => {
             const retornoLexador = microLexador.mapear("'Olá mundo'");
-            const retornoAvaliadorSintatico = microAvaliadorSintatico.analisar(retornoLexador);
+            const retornoAvaliadorSintatico = microAvaliadorSintatico.analisar(retornoLexador, 1);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+        });
+
+        it('Sucesso - Chamada de função', () => {
+            const retornoLexador = microLexador.mapear("somar(2, 3)");
+            const retornoAvaliadorSintatico = microAvaliadorSintatico.analisar(retornoLexador, 1);
 
             expect(retornoAvaliadorSintatico).toBeTruthy();
             expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
diff --git a/testes/micro-lexador.test.ts b/testes/micro-lexador.test.ts
index 572bd99f..0f37a329 100644
--- a/testes/micro-lexador.test.ts
+++ b/testes/micro-lexador.test.ts
@@ -43,6 +43,13 @@ describe('Lexador', () => {
                 expect(resultado).toBeTruthy();
                 expect(resultado.simbolos).toHaveLength(7);
             });
+
+            it('Sucesso - Operações matemáticas encadeadas', () => {
+                const resultado = microLexador.mapear('somar(2, 3)');
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(6);
+            });
         });
     });
 });