@designliquido/delegua 0.2.12 → 0.3.2

package/fontes/interpretador/interpretador.d.ts

@@ -1,11 +1,13 @@
 import { Ambiente } from '../ambiente';
 import { InterpretadorInterface, ResolvedorInterface, SimboloInterface } from '../interfaces';
-import { Classe, Enquanto, Escolha, Escreva, Fazer, Funcao, Importar, Para, Se, Tente } from '../declaracoes';
+import { Bloco, Classe, Declaracao, Enquanto, Escolha, Escreva, Fazer, Funcao, Importar, Para, Retorna, Se, Tente, Var } from '../declaracoes';
 import { DeleguaFuncao } from '../estruturas';
-import { Construto, Super } from '../construtos';
+import { Atribuir, Construto, Super } from '../construtos';
 import { ErroInterpretador } from './erro-interpretador';
 import { RetornoInterpretador } from './retorno-interpretador';
 import { ImportadorInterface } from '../interfaces/importador-interface';
+import { PilhaEscoposExecucao } from './pilha-escopos-execucao';
+import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../quebras';
 /**
  * O Interpretador visita todos os elementos complexos gerados pelo analisador sintático (Parser),
  * e de fato executa a lógica de programação descrita no código.
@@ -14,17 +16,16 @@ export declare class Interpretador implements InterpretadorInterface {
     importador: ImportadorInterface;
     resolvedor: ResolvedorInterface;
     diretorioBase: any;
-    global: Ambiente;
-    ambiente: Ambiente;
     locais: Map<Construto, number>;
     erros: ErroInterpretador[];
     performance: boolean;
     funcaoDeRetorno: Function;
     resultadoInterpretador: Array<String>;
+    pilhaEscoposExecucao: PilhaEscoposExecucao;
     constructor(importador: ImportadorInterface, resolvedor: ResolvedorInterface, diretorioBase: string, performance: boolean, funcaoDeRetorno: Function);
     resolver(expressao: any, profundidade: number): void;
     visitarExpressaoLiteral(expressao: any): any;
-    avaliar(expressao: any): any;
+    avaliar(expressao: Construto): any;
     visitarExpressaoAgrupamento(expressao: any): any;
     eVerdadeiro(objeto: any): boolean;
     verificarOperandoNumero(operador: any, operando: any): void;
@@ -33,25 +34,31 @@ export declare class Interpretador implements InterpretadorInterface {
     verificarOperandosNumeros(operador: any, direita: any, esquerda: any): void;
     visitarExpressaoBinaria(expressao: any): string | number | boolean;
     visitarExpressaoDeChamada(expressao: any): any;
-    visitarExpressaoDeAtribuicao(expressao: any): any;
+    visitarExpressaoDeAtribuicao(expressao: Atribuir): any;
     procurarVariavel(simbolo: SimboloInterface, expressao: any): any;
     visitarExpressaoDeVariavel(expressao: any): any;
     visitarDeclaracaoDeExpressao(declaracao: any): any;
     visitarExpressaoLogica(expressao: any): any;
     visitarExpressaoSe(declaracao: Se): any;
     visitarExpressaoPara(declaracao: Para): any;
-    visitarExpressaoFazer(declaracao: Fazer): void;
-    visitarExpressaoEscolha(declaracao: Escolha): void;
-    visitarExpressaoTente(declaracao: Tente): void;
+    visitarExpressaoFazer(declaracao: Fazer): any;
+    visitarExpressaoEscolha(declaracao: Escolha): any;
+    visitarExpressaoTente(declaracao: Tente): any;
     visitarExpressaoEnquanto(declaracao: Enquanto): any;
-    visitarExpressaoImportar(declaracao: Importar): {};
+    visitarExpressaoImportar(declaracao: Importar): any;
     visitarExpressaoEscreva(declaracao: Escreva): any;
-    executarBloco(declaracoes: any, ambiente: any): void;
-    visitarExpressaoBloco(declaracao: any): any;
-    visitarExpressaoVar(declaracao: any): any;
-    visitarExpressaoContinua(declaracao?: any): void;
-    visitarExpressaoSustar(declaracao?: any): void;
-    visitarExpressaoRetornar(declaracao: any): void;
+    /**
+     * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
+     * executa as declarações empilhadas.
+     * @param declaracoes Um vetor de declaracoes a ser executado.
+     * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
+     */
+    executarBloco(declaracoes: Declaracao[], ambiente?: Ambiente): any;
+    visitarExpressaoBloco(declaracao: Bloco): any;
+    visitarExpressaoVar(declaracao: Var): any;
+    visitarExpressaoContinua(declaracao?: any): ContinuarQuebra;
+    visitarExpressaoSustar(declaracao?: any): SustarQuebra;
+    visitarExpressaoRetornar(declaracao: Retorna): RetornoQuebra;
     visitarExpressaoDeleguaFuncao(expressao: any): DeleguaFuncao;
     visitarExpressaoAtribuicaoSobrescrita(expressao: any): void;
     visitarExpressaoAcessoIndiceVariavel(expressao: any): any;
@@ -64,6 +71,19 @@ export declare class Interpretador implements InterpretadorInterface {
     visitarExpressaoVetor(expressao: any): any[];
     visitarExpressaoSuper(expressao: Super): any;
     paraTexto(objeto: any): any;
-    executar(declaracao: any, mostrarResultado?: boolean): void;
-    interpretar(objeto: any): RetornoInterpretador;
+    executar(declaracao: Declaracao, mostrarResultado?: boolean): any;
+    /**
+     * Executa o último escopo empilhado no topo na pilha de escopos do interpretador.
+     * @param manterAmbiente Se verdadeiro, ambiente do topo da pilha de escopo é copiado para o ambiente imediatamente abaixo.
+     * @returns O resultado da execução do escopo, se houver.
+     */
+    executarUltimoEscopo(manterAmbiente?: boolean): any;
+    /**
+     * Método que efetivamente inicia o processo de interpretação.
+     * @param declaracoes Um vetor de declarações gerado pelo Avaliador Sintático.
+     * @param manterAmbiente Se ambiente de execução (variáveis, classes, etc.) deve ser mantido. Normalmente usado
+     *                       pelo modo REPL (LEIA).
+     * @returns Um objeto com o resultado da interpretação.
+     */
+    interpretar(declaracoes: Declaracao[], manterAmbiente?: boolean): RetornoInterpretador;
 }

package/fontes/interpretador/interpretador.js

@@ -35,6 +35,8 @@ var biblioteca_global_1 = __importDefault(require("../bibliotecas/biblioteca-glo
 var importar_biblioteca_1 = __importDefault(require("../bibliotecas/importar-biblioteca"));
 var excecoes_1 = require("../excecoes");
 var estruturas_1 = require("../estruturas");
+var pilha_escopos_execucao_1 = require("./pilha-escopos-execucao");
+var quebras_1 = require("../quebras");
 /**
  * O Interpretador visita todos os elementos complexos gerados pelo analisador sintático (Parser),
  * e de fato executa a lógica de programação descrita no código.
@@ -49,11 +51,16 @@ var Interpretador = /** @class */ (function () {
         this.diretorioBase = diretorioBase;
         this.performance = performance;
         this.funcaoDeRetorno = funcaoDeRetorno || console.log;
-        this.global = new ambiente_1.Ambiente();
-        this.ambiente = this.global;
         this.locais = new Map();
         this.erros = [];
-        this.global = (0, biblioteca_global_1.default)(this, this.global);
+        this.pilhaEscoposExecucao = new pilha_escopos_execucao_1.PilhaEscoposExecucao();
+        var escopoExecucao = {
+            declaracoes: [],
+            declaracaoAtual: 0,
+            ambiente: new ambiente_1.Ambiente()
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        (0, biblioteca_global_1.default)(this, this.pilhaEscoposExecucao);
     }
     Interpretador.prototype.resolver = function (expressao, profundidade) {
         this.locais.set(expressao, profundidade);
@@ -62,9 +69,7 @@ var Interpretador = /** @class */ (function () {
         return expressao.valor;
     };
     Interpretador.prototype.avaliar = function (expressao) {
-        if (expressao.aceitar) {
-            return expressao.aceitar(this);
-        }
+        return expressao.aceitar(this);
     };
     Interpretador.prototype.visitarExpressaoAgrupamento = function (expressao) {
         return this.avaliar(expressao.expressao);
@@ -198,36 +203,29 @@ var Interpretador = /** @class */ (function () {
         else {
             if (parametros &&
                 parametros.length > 0 &&
-                parametros[parametros.length - 1]['tipo'] === 'wildcard') {
+                parametros[parametros.length - 1]['tipo'] === 'estrela') {
                 var novosArgumentos = argumentos.slice(0, parametros.length - 1);
                 novosArgumentos.push(argumentos.slice(parametros.length - 1, argumentos.length));
                 argumentos = novosArgumentos;
             }
         }
         if (entidadeChamada instanceof estruturas_1.FuncaoPadrao) {
-            return entidadeChamada.chamar(this, argumentos, expressao.entidadeChamada.nome);
+            try {
+                return entidadeChamada.chamar(argumentos, expressao.entidadeChamada.nome);
+            }
+            catch (erro) {
+                this.erros.push(erro);
+            }
         }
         return entidadeChamada.chamar(this, argumentos);
     };
     Interpretador.prototype.visitarExpressaoDeAtribuicao = function (expressao) {
         var valor = this.avaliar(expressao.valor);
-        var distancia = this.locais.get(expressao);
-        if (distancia !== undefined) {
-            this.ambiente.atribuirVariavelEm(distancia, expressao.simbolo, valor);
-        }
-        else {
-            this.ambiente.atribuirVariavel(expressao.simbolo, valor);
-        }
+        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valor);
         return valor;
     };
     Interpretador.prototype.procurarVariavel = function (simbolo, expressao) {
-        var distancia = this.locais.get(expressao);
-        if (distancia !== undefined) {
-            return this.ambiente.obterVariavelEm(distancia, simbolo.lexema);
-        }
-        else {
-            return this.global.obterVariavel(simbolo);
-        }
+        return this.pilhaEscoposExecucao.obterVariavel(simbolo);
     };
     Interpretador.prototype.visitarExpressaoDeVariavel = function (expressao) {
         return this.procurarVariavel(expressao.simbolo, expressao);
@@ -263,8 +261,7 @@ var Interpretador = /** @class */ (function () {
     };
     Interpretador.prototype.visitarExpressaoSe = function (declaracao) {
         if (this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
-            this.executar(declaracao.caminhoEntao);
-            return null;
+            return this.executar(declaracao.caminhoEntao);
         }
         for (var i = 0; i < declaracao.caminhosSeSenao.length; i++) {
             var atual = declaracao.caminhosSeSenao[i];
@@ -282,24 +279,16 @@ var Interpretador = /** @class */ (function () {
         if (declaracao.inicializador !== null) {
             this.avaliar(declaracao.inicializador);
         }
-        while (true) {
-            if (declaracao.condicao !== null) {
-                if (!this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
-                    break;
-                }
+        var retornoExecucao;
+        while (!(retornoExecucao instanceof quebras_1.Quebra)) {
+            if (declaracao.condicao !== null && !this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
+                break;
             }
             try {
-                this.executar(declaracao.corpo);
+                retornoExecucao = this.executar(declaracao.corpo);
             }
             catch (erro) {
-                if (erro instanceof excecoes_1.ExcecaoSustar) {
-                    break;
-                }
-                else if (erro instanceof excecoes_1.ExcecaoContinuar) {
-                }
-                else {
-                    throw erro;
-                }
+                throw erro;
             }
             if (declaracao.incrementar !== null) {
                 this.avaliar(declaracao.incrementar);
@@ -308,21 +297,15 @@ var Interpretador = /** @class */ (function () {
         return null;
     };
     Interpretador.prototype.visitarExpressaoFazer = function (declaracao) {
+        var retornoExecucao;
         do {
             try {
-                this.executar(declaracao.caminhoFazer);
+                retornoExecucao = this.executar(declaracao.caminhoFazer);
             }
             catch (erro) {
-                if (erro instanceof excecoes_1.ExcecaoSustar) {
-                    break;
-                }
-                else if (erro instanceof excecoes_1.ExcecaoContinuar) {
-                }
-                else {
-                    throw erro;
-                }
+                throw erro;
             }
-        } while (this.eVerdadeiro(this.avaliar(declaracao.condicaoEnquanto)));
+        } while (!(retornoExecucao instanceof quebras_1.Quebra) && this.eVerdadeiro(this.avaliar(declaracao.condicaoEnquanto)));
     };
     Interpretador.prototype.visitarExpressaoEscolha = function (declaracao) {
         var condicaoEscolha = this.avaliar(declaracao.condicao);
@@ -332,8 +315,8 @@ var Interpretador = /** @class */ (function () {
         try {
             for (var i = 0; i < caminhos.length; i++) {
                 var caminho_1 = caminhos[i];
-                for (var j = 0; j < caminho_1.conditions.length; j++) {
-                    if (this.avaliar(caminho_1.conditions[j]) === condicaoEscolha) {
+                for (var j = 0; j < caminho_1.condicoes.length; j++) {
+                    if (this.avaliar(caminho_1.condicoes[j]) === condicaoEscolha) {
                         encontrado = true;
                         try {
                             for (var k = 0; k < caminho_1.declaracoes.length; k++) {
@@ -341,11 +324,7 @@ var Interpretador = /** @class */ (function () {
                             }
                         }
                         catch (erro) {
-                            if (erro instanceof excecoes_1.ExcecaoContinuar) {
-                            }
-                            else {
-                                throw erro;
-                            }
+                            throw erro;
                         }
                     }
                 }
@@ -357,48 +336,41 @@ var Interpretador = /** @class */ (function () {
             }
         }
         catch (erro) {
-            if (erro instanceof excecoes_1.ExcecaoSustar) {
-            }
-            else {
-                throw erro;
-            }
+            throw erro;
         }
     };
     Interpretador.prototype.visitarExpressaoTente = function (declaracao) {
         try {
             var sucesso = true;
             try {
-                this.executarBloco(declaracao.caminhoTente, new ambiente_1.Ambiente(this.ambiente));
+                this.executarBloco(declaracao.caminhoTente);
             }
             catch (erro) {
                 sucesso = false;
                 if (declaracao.caminhoPegue !== null) {
-                    this.executarBloco(declaracao.caminhoPegue, new ambiente_1.Ambiente(this.ambiente));
+                    this.executarBloco(declaracao.caminhoPegue);
+                }
+                else {
+                    this.erros.push(erro);
                 }
             }
             if (sucesso && declaracao.caminhoSenao !== null) {
-                this.executarBloco(declaracao.caminhoSenao, new ambiente_1.Ambiente(this.ambiente));
+                this.executarBloco(declaracao.caminhoSenao);
             }
         }
         finally {
             if (declaracao.caminhoFinalmente !== null)
-                this.executarBloco(declaracao.caminhoFinalmente, new ambiente_1.Ambiente(this.ambiente));
+                this.executarBloco(declaracao.caminhoFinalmente);
         }
     };
     Interpretador.prototype.visitarExpressaoEnquanto = function (declaracao) {
-        while (this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
+        var retornoExecucao;
+        while (!(retornoExecucao instanceof quebras_1.Quebra) && this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
             try {
-                this.executar(declaracao.corpo);
+                retornoExecucao = this.executar(declaracao.corpo);
             }
             catch (erro) {
-                if (erro instanceof excecoes_1.ExcecaoSustar) {
-                    break;
-                }
-                else if (erro instanceof excecoes_1.ExcecaoContinuar) {
-                }
-                else {
-                    throw erro;
-                }
+                throw erro;
             }
         }
         return null;
@@ -407,74 +379,77 @@ var Interpretador = /** @class */ (function () {
         var caminhoRelativo = this.avaliar(declaracao.caminho);
         var caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
         var nomeArquivo = caminho.basename(caminhoTotal);
-        if (!caminhoTotal.endsWith('.egua') && !caminhoTotal.endsWith('.delegua')) {
+        if (!caminhoTotal.endsWith('.egua') &&
+            !caminhoTotal.endsWith('.delegua')) {
             return (0, importar_biblioteca_1.default)(caminhoRelativo);
         }
         var conteudoImportacao = this.importador.importar(caminhoRelativo);
-        var retornoInterpretador = this.interpretar(conteudoImportacao.retornoAvaliadorSintatico);
-        var funcoesDeclaradas = this.global.obterTodasDeleguaFuncao();
+        var retornoInterpretador = this.interpretar(conteudoImportacao.retornoAvaliadorSintatico.declaracoes);
+        var funcoesDeclaradas = this.pilhaEscoposExecucao.obterTodasDeleguaFuncao();
         var eDicionario = function (objeto) { return objeto.constructor === Object; };
         if (eDicionario(funcoesDeclaradas)) {
             var novoModulo = new estruturas_1.DeleguaModulo();
             var chaves = Object.keys(funcoesDeclaradas);
             for (var i = 0; i < chaves.length; i++) {
-                novoModulo.componentes[chaves[i]] = funcoesDeclaradas[chaves[i]];
+                novoModulo.componentes[chaves[i]] =
+                    funcoesDeclaradas[chaves[i]];
             }
             return novoModulo;
         }
         return funcoesDeclaradas;
     };
     Interpretador.prototype.visitarExpressaoEscreva = function (declaracao) {
-        var valor = this.avaliar(declaracao.expressao);
-        var formatoTexto = this.paraTexto(valor);
-        this.resultadoInterpretador.push(formatoTexto);
-        this.funcaoDeRetorno(formatoTexto);
-        return null;
-    };
-    Interpretador.prototype.executarBloco = function (declaracoes, ambiente) {
-        var anterior = this.ambiente;
         try {
-            this.ambiente = ambiente;
-            if (declaracoes && declaracoes.length) {
-                for (var i = 0; i < declaracoes.length; i++) {
-                    this.executar(declaracoes[i]);
-                }
-            }
+            var valor = this.avaliar(declaracao.expressao);
+            var formatoTexto = this.paraTexto(valor);
+            this.resultadoInterpretador.push(formatoTexto);
+            this.funcaoDeRetorno(formatoTexto);
+            return null;
         }
         catch (erro) {
-            // TODO: try sem catch é uma roubada total. Implementar uma forma de quebra de fluxo sem exceção.
-            throw erro;
-        }
-        finally {
-            this.ambiente = anterior;
+            this.erros.push(erro);
         }
     };
+    /**
+     * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
+     * executa as declarações empilhadas.
+     * @param declaracoes Um vetor de declaracoes a ser executado.
+     * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
+     */
+    Interpretador.prototype.executarBloco = function (declaracoes, ambiente) {
+        var escopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            ambiente: ambiente || new ambiente_1.Ambiente()
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        return this.executarUltimoEscopo();
+    };
     Interpretador.prototype.visitarExpressaoBloco = function (declaracao) {
-        this.executarBloco(declaracao.declaracoes, new ambiente_1.Ambiente(this.ambiente));
-        return null;
+        return this.executarBloco(declaracao.declaracoes);
     };
     Interpretador.prototype.visitarExpressaoVar = function (declaracao) {
         var valor = null;
         if (declaracao.inicializador !== null) {
             valor = this.avaliar(declaracao.inicializador);
         }
-        this.ambiente.definirVariavel(declaracao.simbolo.lexema, valor);
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valor);
         return null;
     };
     Interpretador.prototype.visitarExpressaoContinua = function (declaracao) {
-        throw new excecoes_1.ExcecaoContinuar();
+        return new quebras_1.ContinuarQuebra();
     };
     Interpretador.prototype.visitarExpressaoSustar = function (declaracao) {
-        throw new excecoes_1.ExcecaoSustar();
+        return new quebras_1.SustarQuebra();
     };
     Interpretador.prototype.visitarExpressaoRetornar = function (declaracao) {
         var valor = null;
         if (declaracao.valor != null)
             valor = this.avaliar(declaracao.valor);
-        throw new excecoes_1.ExcecaoRetornar(valor);
+        return new quebras_1.RetornoQuebra(valor);
     };
     Interpretador.prototype.visitarExpressaoDeleguaFuncao = function (expressao) {
-        return new estruturas_1.DeleguaFuncao(null, expressao, this.ambiente, false);
+        return new estruturas_1.DeleguaFuncao(null, expressao);
     };
     Interpretador.prototype.visitarExpressaoAtribuicaoSobrescrita = function (expressao) {
         var objeto = this.avaliar(expressao.objeto);
@@ -492,7 +467,7 @@ var Interpretador = /** @class */ (function () {
             objeto[indice] = valor;
         }
         else if (objeto.constructor === Object ||
-            objeto instanceof estruturas_1.DeleguaInstancia ||
+            objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
             objeto instanceof estruturas_1.DeleguaFuncao ||
             objeto instanceof estruturas_1.DeleguaClasse ||
             objeto instanceof estruturas_1.DeleguaModulo) {
@@ -520,7 +495,7 @@ var Interpretador = /** @class */ (function () {
             return objeto[indice];
         }
         else if (objeto.constructor === Object ||
-            objeto instanceof estruturas_1.DeleguaInstancia ||
+            objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
             objeto instanceof estruturas_1.DeleguaFuncao ||
             objeto instanceof estruturas_1.DeleguaClasse ||
             objeto instanceof estruturas_1.DeleguaModulo) {
@@ -546,12 +521,12 @@ var Interpretador = /** @class */ (function () {
     };
     Interpretador.prototype.visitarExpressaoDefinir = function (expressao) {
         var objeto = this.avaliar(expressao.objeto);
-        if (!(objeto instanceof estruturas_1.DeleguaInstancia) &&
+        if (!(objeto instanceof estruturas_1.ObjetoDeleguaClasse) &&
             objeto.constructor !== Object) {
             throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha);
         }
         var valor = this.avaliar(expressao.valor);
-        if (objeto instanceof estruturas_1.DeleguaInstancia) {
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse) {
             objeto.set(expressao.nome, valor);
             return valor;
         }
@@ -560,8 +535,8 @@ var Interpretador = /** @class */ (function () {
         }
     };
     Interpretador.prototype.visitarExpressaoFuncao = function (declaracao) {
-        var funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao, this.ambiente, false);
-        this.ambiente.definirVariavel(declaracao.simbolo.lexema, funcao);
+        var funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
     };
     Interpretador.prototype.visitarExpressaoClasse = function (declaracao) {
         var superClasse = null;
@@ -571,29 +546,29 @@ var Interpretador = /** @class */ (function () {
                 throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'SuperClasse precisa ser uma classe.', declaracao.linha);
             }
         }
-        this.ambiente.definirVariavel(declaracao.simbolo.lexema, null);
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, null);
         if (declaracao.superClasse !== null) {
-            this.ambiente = new ambiente_1.Ambiente(this.ambiente);
-            this.ambiente.definirVariavel('super', superClasse);
+            this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
         }
         var metodos = {};
         var definirMetodos = declaracao.metodos;
         for (var i = 0; i < declaracao.metodos.length; i++) {
             var metodoAtual = definirMetodos[i];
-            var eInicializado = metodoAtual.simbolo.lexema === 'construtor';
-            var funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, this.ambiente, eInicializado);
+            var eInicializador = metodoAtual.simbolo.lexema === 'construtor';
+            var funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
             metodos[metodoAtual.simbolo.lexema] = funcao;
         }
         var criado = new estruturas_1.DeleguaClasse(declaracao.simbolo.lexema, superClasse, metodos);
-        if (superClasse !== null) {
+        // TODO: Recolocar isso se for necessário.
+        /* if (superClasse !== null) {
             this.ambiente = this.ambiente.enclosing;
-        }
-        this.ambiente.atribuirVariavel(declaracao.simbolo, criado);
+        } */
+        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, criado);
         return null;
     };
     Interpretador.prototype.visitarExpressaoAcessoMetodo = function (expressao) {
         var objeto = this.avaliar(expressao.objeto);
-        if (objeto instanceof estruturas_1.DeleguaInstancia) {
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse) {
             return objeto.get(expressao.simbolo) || null;
         }
         else if (objeto.constructor === Object) {
@@ -623,13 +598,13 @@ var Interpretador = /** @class */ (function () {
     };
     Interpretador.prototype.visitarExpressaoSuper = function (expressao) {
         var distancia = this.locais.get(expressao);
-        var superClasse = this.ambiente.obterVariavelEm(distancia, 'super');
-        var objeto = this.ambiente.obterVariavelEm(distancia - 1, 'isto');
+        var superClasse = this.pilhaEscoposExecucao.obterVariavelEm(distancia, 'super');
+        var objeto = this.pilhaEscoposExecucao.obterVariavelEm(distancia - 1, 'isto');
         var metodo = superClasse.encontrarMetodo(expressao.metodo.lexema);
         if (metodo === undefined) {
             throw new excecoes_1.ErroEmTempoDeExecucao(expressao.metodo, 'Método chamado indefinido.', expressao.linha);
         }
-        return metodo.definirEscopo(objeto);
+        return metodo.definirInstancia(objeto);
     };
     Interpretador.prototype.paraTexto = function (objeto) {
         if (objeto === null)
@@ -648,6 +623,9 @@ var Interpretador = /** @class */ (function () {
             return objeto;
         if (typeof objeto === 'object')
             return JSON.stringify(objeto);
+        if (objeto === undefined) {
+            return 'nulo';
+        }
         return objeto.toString();
     };
     Interpretador.prototype.executar = function (declaracao, mostrarResultado) {
@@ -659,27 +637,52 @@ var Interpretador = /** @class */ (function () {
         if (resultado || typeof resultado === 'boolean') {
             this.resultadoInterpretador.push(this.paraTexto(resultado));
         }
+        return resultado;
     };
-    Interpretador.prototype.interpretar = function (objeto) {
+    /**
+     * Executa o último escopo empilhado no topo na pilha de escopos do interpretador.
+     * @param manterAmbiente Se verdadeiro, ambiente do topo da pilha de escopo é copiado para o ambiente imediatamente abaixo.
+     * @returns O resultado da execução do escopo, se houver.
+     */
+    Interpretador.prototype.executarUltimoEscopo = function (manterAmbiente) {
+        if (manterAmbiente === void 0) { manterAmbiente = false; }
+        var ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
+        try {
+            var retornoExecucao = void 0;
+            for (; !(retornoExecucao instanceof quebras_1.Quebra) && ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length; ultimoEscopo.declaracaoAtual++) {
+                retornoExecucao = this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
+            }
+            return retornoExecucao;
+        }
+        finally {
+            this.pilhaEscoposExecucao.removerUltimo();
+            if (manterAmbiente) {
+                var escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
+                escopoAnterior.ambiente.valores = Object.assign(escopoAnterior.ambiente.valores, ultimoEscopo.ambiente.valores);
+            }
+        }
+    };
+    /**
+     * Método que efetivamente inicia o processo de interpretação.
+     * @param declaracoes Um vetor de declarações gerado pelo Avaliador Sintático.
+     * @param manterAmbiente Se ambiente de execução (variáveis, classes, etc.) deve ser mantido. Normalmente usado
+     *                       pelo modo REPL (LEIA).
+     * @returns Um objeto com o resultado da interpretação.
+     */
+    Interpretador.prototype.interpretar = function (declaracoes, manterAmbiente) {
+        if (manterAmbiente === void 0) { manterAmbiente = false; }
         this.erros = [];
-        var retornoResolvedor = this.resolvedor.resolver(objeto);
+        var retornoResolvedor = this.resolvedor.resolver(declaracoes);
         this.locais = retornoResolvedor.locais;
+        var escopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            ambiente: new ambiente_1.Ambiente()
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
         var inicioInterpretacao = (0, browser_process_hrtime_1.default)();
         try {
-            var declaracoes = objeto.declaracoes || objeto;
-            if (declaracoes.length === 1) {
-                var eObjetoExpressao = declaracoes[0].constructor.name === 'Expressao';
-                if (eObjetoExpressao) {
-                    this.executar(declaracoes[0], true);
-                    return;
-                }
-            }
-            for (var i = 0; i < declaracoes.length; i++) {
-                this.executar(declaracoes[i]);
-            }
-        }
-        catch (erro) {
-            this.erros.push(erro);
+            this.executarUltimoEscopo(manterAmbiente);
         }
         finally {
             if (this.performance) {
@@ -688,7 +691,7 @@ var Interpretador = /** @class */ (function () {
             }
             var retorno = {
                 erros: this.erros,
-                resultado: this.resultadoInterpretador
+                resultado: this.resultadoInterpretador,
             };
             this.resultadoInterpretador = [];
             return retorno;