@designliquido/delegua 0.2.1 → 0.2.2

package/{src → fontes}/interpretador/index.js

@@ -1,23 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Interpretador = void 0;
-var tiposDeSimbolos_1 = require("../tiposDeSimbolos");
+var caminho = __importStar(require("path"));
+var fs = __importStar(require("fs"));
 var perf_hooks_1 = require("perf_hooks");
+var tiposDeSimbolos_1 = __importDefault(require("../tiposDeSimbolos"));
 var ambiente_1 = require("../ambiente");
 var delegua_1 = require("../delegua");
-var biblioteca_global_1 = require("../bibliotecas/biblioteca-global");
-var caminho = require("path");
-var fs = require("fs");
-var importar_biblioteca_1 = require("../bibliotecas/importar-biblioteca");
-var chamavel_1 = require("../estruturas/chamavel");
-var funcao_padrao_1 = require("../estruturas/funcao-padrao");
-var classe_1 = require("../estruturas/classe");
-var funcao_1 = require("../estruturas/funcao");
-var instancia_1 = require("../estruturas/instancia");
-var modulo_1 = require("../estruturas/modulo");
+var biblioteca_global_1 = __importDefault(require("../bibliotecas/biblioteca-global"));
+var importar_biblioteca_1 = __importDefault(require("../bibliotecas/importar-biblioteca"));
 var excecoes_1 = require("../excecoes");
+var estruturas_1 = require("../estruturas");
 /**
- * O Interpretador visita todos os elementos complexos gerados pelo analisador sintático (Parser)
+ * 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.
  */
 var Interpretador = /** @class */ (function () {
@@ -31,19 +52,19 @@ var Interpretador = /** @class */ (function () {
         this.locais = new Map();
         this.global = (0, biblioteca_global_1.default)(this, this.global);
     }
-    Interpretador.prototype.resolver = function (expr, depth) {
-        this.locais.set(expr, depth);
+    Interpretador.prototype.resolver = function (expressao, profundidade) {
+        this.locais.set(expressao, profundidade);
     };
-    Interpretador.prototype.visitarExpressaoLiteral = function (expr) {
-        return expr.valor;
+    Interpretador.prototype.visitarExpressaoLiteral = function (expressao) {
+        return expressao.valor;
     };
-    Interpretador.prototype.avaliar = function (expr) {
-        if (expr.aceitar) {
-            return expr.aceitar(this);
+    Interpretador.prototype.avaliar = function (expressao) {
+        if (expressao.aceitar) {
+            return expressao.aceitar(this);
         }
     };
-    Interpretador.prototype.visitarExpressaoAgrupamento = function (expr) {
-        return this.avaliar(expr.expressao);
+    Interpretador.prototype.visitarExpressaoAgrupamento = function (expressao) {
+        return this.avaliar(expressao.expressao);
     };
     Interpretador.prototype.eVerdadeiro = function (objeto) {
         if (objeto === null)
@@ -55,13 +76,13 @@ var Interpretador = /** @class */ (function () {
     Interpretador.prototype.verificarOperandoNumero = function (operador, operando) {
         if (typeof operando === 'number')
             return;
-        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operando precisa ser um número.');
+        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operando precisa ser um número.', operador.linha);
     };
-    Interpretador.prototype.visitarExpressaoUnaria = function (expr) {
-        var direita = this.avaliar(expr.direita);
-        switch (expr.operador.tipo) {
+    Interpretador.prototype.visitarExpressaoUnaria = function (expressao) {
+        var direita = this.avaliar(expressao.direita);
+        switch (expressao.operador.tipo) {
             case tiposDeSimbolos_1.default.SUBTRACAO:
-                this.verificarOperandoNumero(expr.operador, direita);
+                this.verificarOperandoNumero(expressao.operador, direita);
                 return -direita;
             case tiposDeSimbolos_1.default.NEGACAO:
                 return !this.eVerdadeiro(direita);
@@ -80,29 +101,29 @@ var Interpretador = /** @class */ (function () {
     Interpretador.prototype.verificarOperandosNumeros = function (operador, direita, esquerda) {
         if (typeof direita === 'number' && typeof esquerda === 'number')
             return;
-        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operandos precisam ser números.');
+        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operandos precisam ser números.', operador.linha);
     };
-    Interpretador.prototype.visitarExpressaoBinaria = function (expr) {
-        var esquerda = this.avaliar(expr.esquerda);
-        var direita = this.avaliar(expr.direita);
-        switch (expr.operador.tipo) {
+    Interpretador.prototype.visitarExpressaoBinaria = function (expressao) {
+        var esquerda = this.avaliar(expressao.esquerda);
+        var direita = this.avaliar(expressao.direita);
+        switch (expressao.operador.tipo) {
             case tiposDeSimbolos_1.default.EXPONENCIACAO:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Math.pow(esquerda, direita);
             case tiposDeSimbolos_1.default.MAIOR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) > Number(direita);
             case tiposDeSimbolos_1.default.MAIOR_IGUAL:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) >= Number(direita);
             case tiposDeSimbolos_1.default.MENOR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) < Number(direita);
             case tiposDeSimbolos_1.default.MENOR_IGUAL:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) <= Number(direita);
             case tiposDeSimbolos_1.default.SUBTRACAO:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) - Number(direita);
             case tiposDeSimbolos_1.default.ADICAO:
                 if (typeof esquerda === 'number' &&
@@ -113,28 +134,28 @@ var Interpretador = /** @class */ (function () {
                     return String(esquerda) + String(direita);
                 }
             case tiposDeSimbolos_1.default.DIVISAO:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) / Number(direita);
             case tiposDeSimbolos_1.default.MULTIPLICACAO:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) * Number(direita);
             case tiposDeSimbolos_1.default.MODULO:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) % Number(direita);
             case tiposDeSimbolos_1.default.BIT_AND:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) & Number(direita);
             case tiposDeSimbolos_1.default.BIT_XOR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) ^ Number(direita);
             case tiposDeSimbolos_1.default.BIT_OR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) | Number(direita);
             case tiposDeSimbolos_1.default.MENOR_MENOR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) << Number(direita);
             case tiposDeSimbolos_1.default.MAIOR_MAIOR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 return Number(esquerda) >> Number(direita);
             case tiposDeSimbolos_1.default.DIFERENTE:
                 return !this.eIgual(esquerda, direita);
@@ -143,20 +164,20 @@ var Interpretador = /** @class */ (function () {
         }
         return null;
     };
-    Interpretador.prototype.visitarExpressaoDeChamada = function (expr) {
-        var entidadeChamada = this.avaliar(expr.entidadeChamada);
+    Interpretador.prototype.visitarExpressaoDeChamada = function (expressao) {
+        var entidadeChamada = this.avaliar(expressao.entidadeChamada);
         var argumentos = [];
-        for (var i = 0; i < expr.argumentos.length; i++) {
-            argumentos.push(this.avaliar(expr.argumentos[i]));
+        for (var i = 0; i < expressao.argumentos.length; i++) {
+            argumentos.push(this.avaliar(expressao.argumentos[i]));
         }
-        if (!(entidadeChamada instanceof chamavel_1.Chamavel)) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.parentese, 'Só pode chamar função ou classe.');
+        if (!(entidadeChamada instanceof estruturas_1.Chamavel)) {
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha);
         }
         var parametros;
-        if (entidadeChamada instanceof funcao_1.DeleguaFuncao) {
+        if (entidadeChamada instanceof estruturas_1.DeleguaFuncao) {
             parametros = entidadeChamada.declaracao.parametros;
         }
-        else if (entidadeChamada instanceof classe_1.DeleguaClasse) {
+        else if (entidadeChamada instanceof estruturas_1.DeleguaClasse) {
             parametros = entidadeChamada.metodos.init
                 ? entidadeChamada.metodos.init.declaracao.parametros
                 : [];
@@ -180,41 +201,41 @@ var Interpretador = /** @class */ (function () {
                 argumentos = novosArgumentos;
             }
         }
-        if (entidadeChamada instanceof funcao_padrao_1.FuncaoPadrao) {
-            return entidadeChamada.chamar(this, argumentos, expr.entidadeChamada.nome);
+        if (entidadeChamada instanceof estruturas_1.FuncaoPadrao) {
+            return entidadeChamada.chamar(this, argumentos, expressao.entidadeChamada.nome);
         }
         return entidadeChamada.chamar(this, argumentos);
     };
-    Interpretador.prototype.visitarExpressaoDeAtribuicao = function (expr) {
-        var valor = this.avaliar(expr.valor);
-        var distancia = this.locais.get(expr);
+    Interpretador.prototype.visitarExpressaoDeAtribuicao = function (expressao) {
+        var valor = this.avaliar(expressao.valor);
+        var distancia = this.locais.get(expressao);
         if (distancia !== undefined) {
-            this.ambiente.atribuirVariavelEm(distancia, expr.nome, valor);
+            this.ambiente.atribuirVariavelEm(distancia, expressao.simbolo, valor);
         }
         else {
-            this.ambiente.atribuirVariavel(expr.nome, valor);
+            this.ambiente.atribuirVariavel(expressao.simbolo, valor);
         }
         return valor;
     };
-    Interpretador.prototype.procurarVariavel = function (nome, expr) {
-        var distancia = this.locais.get(expr);
+    Interpretador.prototype.procurarVariavel = function (simbolo, expressao) {
+        var distancia = this.locais.get(expressao);
         if (distancia !== undefined) {
-            return this.ambiente.obterVariavelEm(distancia, nome.lexema);
+            return this.ambiente.obterVariavelEm(distancia, simbolo.lexema);
         }
         else {
-            return this.global.obterVariavel(nome);
+            return this.global.obterVariavel(simbolo);
         }
     };
-    Interpretador.prototype.visitarExpressaoDeVariavel = function (expr) {
-        return this.procurarVariavel(expr.nome, expr);
+    Interpretador.prototype.visitarExpressaoDeVariavel = function (expressao) {
+        return this.procurarVariavel(expressao.simbolo, expressao);
     };
-    Interpretador.prototype.visitarDeclaracaoDeExpressao = function (stmt) {
-        return this.avaliar(stmt.expressao);
+    Interpretador.prototype.visitarDeclaracaoDeExpressao = function (declaracao) {
+        return this.avaliar(declaracao.expressao);
     };
-    Interpretador.prototype.visitarExpressaoLogica = function (expr) {
-        var esquerda = this.avaliar(expr.esquerda);
-        if (expr.operador.tipo === tiposDeSimbolos_1.default.EM) {
-            var direita = this.avaliar(expr.direita);
+    Interpretador.prototype.visitarExpressaoLogica = function (expressao) {
+        var esquerda = this.avaliar(expressao.esquerda);
+        if (expressao.operador.tipo === tiposDeSimbolos_1.default.EM) {
+            var direita = this.avaliar(expressao.direita);
             if (Array.isArray(direita) || typeof direita === 'string') {
                 return direita.includes(esquerda);
             }
@@ -222,53 +243,53 @@ var Interpretador = /** @class */ (function () {
                 return esquerda in direita;
             }
             else {
-                throw new excecoes_1.ErroEmTempoDeExecucao("Tipo de chamada inválida com 'em'.");
+                throw new excecoes_1.ErroEmTempoDeExecucao(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
             }
         }
         // se um estado for verdadeiro, retorna verdadeiro
-        if (expr.operador.tipo === tiposDeSimbolos_1.default.OU) {
+        if (expressao.operador.tipo === tiposDeSimbolos_1.default.OU) {
             if (this.eVerdadeiro(esquerda))
                 return esquerda;
         }
         // se um estado for falso, retorna falso
-        if (expr.operador.tipo === tiposDeSimbolos_1.default.E) {
+        if (expressao.operador.tipo === tiposDeSimbolos_1.default.E) {
             if (!this.eVerdadeiro(esquerda))
                 return esquerda;
         }
-        return this.avaliar(expr.direita);
+        return this.avaliar(expressao.direita);
     };
-    Interpretador.prototype.visitarExpressaoSe = function (stmt) {
-        if (this.eVerdadeiro(this.avaliar(stmt.condicao))) {
-            this.executar(stmt.thenBranch);
+    Interpretador.prototype.visitarExpressaoSe = function (declaracao) {
+        if (this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
+            this.executar(declaracao.caminhoEntao);
             return null;
         }
-        for (var i = 0; i < stmt.elifBranches.length; i++) {
-            var atual = stmt.elifBranches[i];
+        for (var i = 0; i < declaracao.caminhosSeSenao.length; i++) {
+            var atual = declaracao.caminhosSeSenao[i];
             if (this.eVerdadeiro(this.avaliar(atual.condicao))) {
-                this.executar(atual.branch);
+                this.executar(atual.caminho);
                 return null;
             }
         }
-        if (stmt.elseBranch !== null) {
-            this.executar(stmt.elseBranch);
+        if (declaracao.caminhoSenao !== null) {
+            this.executar(declaracao.caminhoSenao);
         }
         return null;
     };
-    Interpretador.prototype.visitarExpressaoPara = function (stmt) {
-        if (stmt.inicializador !== null) {
-            this.avaliar(stmt.inicializador);
+    Interpretador.prototype.visitarExpressaoPara = function (declaracao) {
+        if (declaracao.inicializador !== null) {
+            this.avaliar(declaracao.inicializador);
         }
         while (true) {
-            if (stmt.condicao !== null) {
-                if (!this.eVerdadeiro(this.avaliar(stmt.condicao))) {
+            if (declaracao.condicao !== null) {
+                if (!this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
                     break;
                 }
             }
             try {
-                this.executar(stmt.corpo);
+                this.executar(declaracao.corpo);
             }
             catch (erro) {
-                if (erro instanceof excecoes_1.ExcecaoQuebra) {
+                if (erro instanceof excecoes_1.ExcecaoSustar) {
                     break;
                 }
                 else if (erro instanceof excecoes_1.ExcecaoContinuar) {
@@ -277,19 +298,19 @@ var Interpretador = /** @class */ (function () {
                     throw erro;
                 }
             }
-            if (stmt.incrementar !== null) {
-                this.avaliar(stmt.incrementar);
+            if (declaracao.incrementar !== null) {
+                this.avaliar(declaracao.incrementar);
             }
         }
         return null;
     };
-    Interpretador.prototype.visitarExpressaoFazer = function (stmt) {
+    Interpretador.prototype.visitarExpressaoFazer = function (declaracao) {
         do {
             try {
-                this.executar(stmt.doBranch);
+                this.executar(declaracao.caminhoFazer);
             }
             catch (erro) {
-                if (erro instanceof excecoes_1.ExcecaoQuebra) {
+                if (erro instanceof excecoes_1.ExcecaoSustar) {
                     break;
                 }
                 else if (erro instanceof excecoes_1.ExcecaoContinuar) {
@@ -298,22 +319,22 @@ var Interpretador = /** @class */ (function () {
                     throw erro;
                 }
             }
-        } while (this.eVerdadeiro(this.avaliar(stmt.whileCondition)));
+        } while (this.eVerdadeiro(this.avaliar(declaracao.condicaoEnquanto)));
     };
-    Interpretador.prototype.visitarExpressaoEscolha = function (stmt) {
-        var switchCondition = this.avaliar(stmt.condicao);
-        var branches = stmt.branches;
-        var defaultBranch = stmt.defaultBranch;
-        var matched = false;
+    Interpretador.prototype.visitarExpressaoEscolha = function (declaracao) {
+        var condicaoEscolha = this.avaliar(declaracao.condicao);
+        var caminhos = declaracao.caminhos;
+        var caminhoPadrao = declaracao.caminhoPadrao;
+        var encontrado = false;
         try {
-            for (var i = 0; i < branches.length; i++) {
-                var branch = branches[i];
-                for (var j = 0; j < branch.conditions.length; j++) {
-                    if (this.avaliar(branch.conditions[j]) === switchCondition) {
-                        matched = true;
+            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) {
+                        encontrado = true;
                         try {
-                            for (var k = 0; k < branch.stmts.length; k++) {
-                                this.executar(branch.stmts[k]);
+                            for (var k = 0; k < caminho_1.declaracoes.length; k++) {
+                                this.executar(caminho_1.declaracoes[k]);
                             }
                         }
                         catch (erro) {
@@ -326,48 +347,48 @@ var Interpretador = /** @class */ (function () {
                     }
                 }
             }
-            if (defaultBranch !== null && matched === false) {
-                for (var i = 0; i < defaultBranch.stmts.length; i++) {
-                    this.executar(defaultBranch['stmts'][i]);
+            if (caminhoPadrao !== null && encontrado === false) {
+                for (var i = 0; i < caminhoPadrao.declaracoes.length; i++) {
+                    this.executar(caminhoPadrao['declaracoes'][i]);
                 }
             }
         }
         catch (erro) {
-            if (erro instanceof excecoes_1.ExcecaoQuebra) {
+            if (erro instanceof excecoes_1.ExcecaoSustar) {
             }
             else {
                 throw erro;
             }
         }
     };
-    Interpretador.prototype.visitarExpressaoTente = function (stmt) {
+    Interpretador.prototype.visitarExpressaoTente = function (declaracao) {
         try {
             var sucesso = true;
             try {
-                this.executarBloco(stmt.tryBranch, new ambiente_1.Ambiente(this.ambiente));
+                this.executarBloco(declaracao.caminhoTente, new ambiente_1.Ambiente(this.ambiente));
             }
             catch (erro) {
                 sucesso = false;
-                if (stmt.catchBranch !== null) {
-                    this.executarBloco(stmt.catchBranch, new ambiente_1.Ambiente(this.ambiente));
+                if (declaracao.caminhoPegue !== null) {
+                    this.executarBloco(declaracao.caminhoPegue, new ambiente_1.Ambiente(this.ambiente));
                 }
             }
-            if (sucesso && stmt.elseBranch !== null) {
-                this.executarBloco(stmt.elseBranch, new ambiente_1.Ambiente(this.ambiente));
+            if (sucesso && declaracao.caminhoSenao !== null) {
+                this.executarBloco(declaracao.caminhoSenao, new ambiente_1.Ambiente(this.ambiente));
             }
         }
         finally {
-            if (stmt.finallyBranch !== null)
-                this.executarBloco(stmt.finallyBranch, new ambiente_1.Ambiente(this.ambiente));
+            if (declaracao.caminhoFinalmente !== null)
+                this.executarBloco(declaracao.caminhoFinalmente, new ambiente_1.Ambiente(this.ambiente));
         }
     };
-    Interpretador.prototype.visitarExpressaoEnquanto = function (stmt) {
-        while (this.eVerdadeiro(this.avaliar(stmt.condicao))) {
+    Interpretador.prototype.visitarExpressaoEnquanto = function (declaracao) {
+        while (this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
             try {
-                this.executar(stmt.corpo);
+                this.executar(declaracao.corpo);
             }
             catch (erro) {
-                if (erro instanceof excecoes_1.ExcecaoQuebra) {
+                if (erro instanceof excecoes_1.ExcecaoSustar) {
                     break;
                 }
                 else if (erro instanceof excecoes_1.ExcecaoContinuar) {
@@ -379,43 +400,40 @@ var Interpretador = /** @class */ (function () {
         }
         return null;
     };
-    Interpretador.prototype.visitarExpressaoImportar = function (stmt) {
-        var caminhoRelativo = this.avaliar(stmt.caminho);
+    Interpretador.prototype.visitarExpressaoImportar = function (declaracao) {
+        var caminhoRelativo = this.avaliar(declaracao.caminho);
         var caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
-        // const pastaTotal = caminho.dirname(caminhoTotal);
         var nomeArquivo = caminho.basename(caminhoTotal);
-        var conteudoImportacao;
-        if (!caminhoTotal.endsWith('.egua')) {
-            conteudoImportacao = (0, importar_biblioteca_1.default)(caminhoRelativo);
-            if (conteudoImportacao)
-                return conteudoImportacao;
+        if (!caminhoTotal.endsWith('.egua') && !caminhoTotal.endsWith('.delegua')) {
+            return (0, importar_biblioteca_1.default)(caminhoRelativo);
         }
         try {
             if (!fs.existsSync(caminhoTotal)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(stmt.closeBracket, 'Não foi possível encontrar arquivo importado.');
+                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível encontrar arquivo importado.', declaracao.linha);
             }
         }
         catch (erro) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(stmt.closeBracket, 'Não foi possível ler o arquivo.');
+            throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível ler o arquivo.', declaracao.linha);
         }
-        conteudoImportacao = fs.readFileSync(caminhoTotal).toString();
+        var conteudoImportacao = fs.readFileSync(caminhoTotal)
+            .toString()
+            .split('\n');
         var delegua = new delegua_1.Delegua(this.Delegua.dialeto, this.performance, nomeArquivo);
         delegua.executar(conteudoImportacao);
-        // let exportar = delegua.interpretador.global.obterTodasDeleguaFuncao();
-        var exportar = delegua.interpretador.global.valores.exports;
+        var funcoesDeclaradas = delegua.interpretador.global.obterTodasDeleguaFuncao();
         var eDicionario = function (objeto) { return objeto.constructor === Object; };
-        if (eDicionario(exportar)) {
-            var novoModulo = new modulo_1.DeleguaModulo();
-            var chaves = Object.keys(exportar);
+        if (eDicionario(funcoesDeclaradas)) {
+            var novoModulo = new estruturas_1.DeleguaModulo();
+            var chaves = Object.keys(funcoesDeclaradas);
             for (var i = 0; i < chaves.length; i++) {
-                novoModulo[chaves[i]] = exportar[chaves[i]];
+                novoModulo.componentes[chaves[i]] = funcoesDeclaradas[chaves[i]];
             }
             return novoModulo;
         }
-        return exportar;
+        return funcoesDeclaradas;
     };
-    Interpretador.prototype.visitarExpressaoEscreva = function (stmt) {
-        var valor = this.avaliar(stmt.expressao);
+    Interpretador.prototype.visitarExpressaoEscreva = function (declaracao) {
+        var valor = this.avaliar(declaracao.expressao);
         console.log(this.paraTexto(valor));
         return null;
     };
@@ -437,37 +455,37 @@ var Interpretador = /** @class */ (function () {
             this.ambiente = anterior;
         }
     };
-    Interpretador.prototype.visitarExpressaoBloco = function (stmt) {
-        this.executarBloco(stmt.declaracoes, new ambiente_1.Ambiente(this.ambiente));
+    Interpretador.prototype.visitarExpressaoBloco = function (declaracao) {
+        this.executarBloco(declaracao.declaracoes, new ambiente_1.Ambiente(this.ambiente));
         return null;
     };
-    Interpretador.prototype.visitarExpressaoVar = function (stmt) {
+    Interpretador.prototype.visitarExpressaoVar = function (declaracao) {
         var valor = null;
-        if (stmt.inicializador !== null) {
-            valor = this.avaliar(stmt.inicializador);
+        if (declaracao.inicializador !== null) {
+            valor = this.avaliar(declaracao.inicializador);
         }
-        this.ambiente.definirVariavel(stmt.nome.lexema, valor);
+        this.ambiente.definirVariavel(declaracao.simbolo.lexema, valor);
         return null;
     };
-    Interpretador.prototype.visitarExpressaoContinua = function (stmt) {
+    Interpretador.prototype.visitarExpressaoContinua = function (declaracao) {
         throw new excecoes_1.ExcecaoContinuar();
     };
-    Interpretador.prototype.visitarExpressaoPausa = function (stmt) {
-        throw new excecoes_1.ExcecaoQuebra();
+    Interpretador.prototype.visitarExpressaoSustar = function (declaracao) {
+        throw new excecoes_1.ExcecaoSustar();
     };
-    Interpretador.prototype.visitarExpressaoRetornar = function (stmt) {
+    Interpretador.prototype.visitarExpressaoRetornar = function (declaracao) {
         var valor = null;
-        if (stmt.valor != null)
-            valor = this.avaliar(stmt.valor);
+        if (declaracao.valor != null)
+            valor = this.avaliar(declaracao.valor);
         throw new excecoes_1.ExcecaoRetornar(valor);
     };
-    Interpretador.prototype.visitarExpressaoDeleguaFuncao = function (expr) {
-        return new funcao_1.DeleguaFuncao(null, expr, this.ambiente, false);
+    Interpretador.prototype.visitarExpressaoDeleguaFuncao = function (expressao) {
+        return new estruturas_1.DeleguaFuncao(null, expressao, this.ambiente, false);
     };
-    Interpretador.prototype.visitarExpressaoAtribuicaoSobrescrita = function (expr) {
-        var objeto = this.avaliar(expr.objeto);
-        var indice = this.avaliar(expr.indice);
-        var valor = this.avaliar(expr.valor);
+    Interpretador.prototype.visitarExpressaoAtribuicaoSobrescrita = function (expressao) {
+        var objeto = this.avaliar(expressao.objeto);
+        var indice = this.avaliar(expressao.indice);
+        var valor = this.avaliar(expressao.valor);
         if (Array.isArray(objeto)) {
             if (indice < 0 && objeto.length !== 0) {
                 while (indice < 0) {
@@ -480,22 +498,22 @@ var Interpretador = /** @class */ (function () {
             objeto[indice] = valor;
         }
         else if (objeto.constructor === Object ||
-            objeto instanceof instancia_1.DeleguaInstancia ||
-            objeto instanceof funcao_1.DeleguaFuncao ||
-            objeto instanceof classe_1.DeleguaClasse ||
-            objeto instanceof modulo_1.DeleguaModulo) {
+            objeto instanceof estruturas_1.DeleguaInstancia ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaModulo) {
             objeto[indice] = valor;
         }
         else {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.');
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha);
         }
     };
-    Interpretador.prototype.visitarExpressaoVetorIndice = function (expressao) {
+    Interpretador.prototype.visitarExpressaoAcessoIndiceVariavel = function (expressao) {
         var objeto = this.avaliar(expressao.entidadeChamada);
         var indice = this.avaliar(expressao.indice);
         if (Array.isArray(objeto)) {
             if (!Number.isInteger(indice)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, 'Somente inteiros podem ser usados para indexar um vetor.');
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha);
             }
             if (indice < 0 && objeto.length !== 0) {
                 while (indice < 0) {
@@ -503,20 +521,20 @@ var Interpretador = /** @class */ (function () {
                 }
             }
             if (indice >= objeto.length) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, 'Índice do vetor fora do intervalo.');
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha);
             }
             return objeto[indice];
         }
         else if (objeto.constructor === Object ||
-            objeto instanceof instancia_1.DeleguaInstancia ||
-            objeto instanceof funcao_1.DeleguaFuncao ||
-            objeto instanceof classe_1.DeleguaClasse ||
-            objeto instanceof modulo_1.DeleguaModulo) {
+            objeto instanceof estruturas_1.DeleguaInstancia ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaModulo) {
             return objeto[indice] || null;
         }
         else if (typeof objeto === 'string') {
             if (!Number.isInteger(indice)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, 'Somente inteiros podem ser usados para indexar um vetor.');
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha);
             }
             if (indice < 0 && objeto.length !== 0) {
                 while (indice < 0) {
@@ -524,98 +542,98 @@ var Interpretador = /** @class */ (function () {
                 }
             }
             if (indice >= objeto.length) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, 'Índice fora do tamanho.');
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha);
             }
             return objeto.charAt(indice);
         }
         else {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.');
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha);
         }
     };
-    Interpretador.prototype.visitarExpressaoDefinir = function (expr) {
-        var objeto = this.avaliar(expr.objeto);
-        if (!(objeto instanceof instancia_1.DeleguaInstancia) &&
+    Interpretador.prototype.visitarExpressaoDefinir = function (expressao) {
+        var objeto = this.avaliar(expressao.objeto);
+        if (!(objeto instanceof estruturas_1.DeleguaInstancia) &&
             objeto.constructor !== Object) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.objeto.nome, 'Somente instâncias e dicionários podem possuir campos.');
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha);
         }
-        var valor = this.avaliar(expr.valor);
-        if (objeto instanceof instancia_1.DeleguaInstancia) {
-            objeto.set(expr.nome, valor);
+        var valor = this.avaliar(expressao.valor);
+        if (objeto instanceof estruturas_1.DeleguaInstancia) {
+            objeto.set(expressao.nome, valor);
             return valor;
         }
         else if (objeto.constructor === Object) {
-            objeto[expr.nome.lexema] = valor;
+            objeto[expressao.simbolo.lexema] = valor;
         }
     };
-    Interpretador.prototype.visitarExpressaoFuncao = function (stmt) {
-        var funcao = new funcao_1.DeleguaFuncao(stmt.nome.lexema, stmt.funcao, this.ambiente, false);
-        this.ambiente.definirVariavel(stmt.nome.lexema, funcao);
+    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);
     };
-    Interpretador.prototype.visitarExpressaoClasse = function (stmt) {
+    Interpretador.prototype.visitarExpressaoClasse = function (declaracao) {
         var superClasse = null;
-        if (stmt.superClasse !== null) {
-            superClasse = this.avaliar(stmt.superClasse);
-            if (!(superClasse instanceof classe_1.DeleguaClasse)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(stmt.superClasse.nome, 'SuperClasse precisa ser uma classe.');
+        if (declaracao.superClasse !== null) {
+            superClasse = this.avaliar(declaracao.superClasse);
+            if (!(superClasse instanceof estruturas_1.DeleguaClasse)) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'SuperClasse precisa ser uma classe.', declaracao.linha);
             }
         }
-        this.ambiente.definirVariavel(stmt.nome.lexema, null);
-        if (stmt.superClasse !== null) {
+        this.ambiente.definirVariavel(declaracao.simbolo.lexema, null);
+        if (declaracao.superClasse !== null) {
             this.ambiente = new ambiente_1.Ambiente(this.ambiente);
             this.ambiente.definirVariavel('super', superClasse);
         }
         var metodos = {};
-        var definirMetodos = stmt.metodos;
-        for (var i = 0; i < stmt.metodos.length; i++) {
+        var definirMetodos = declaracao.metodos;
+        for (var i = 0; i < declaracao.metodos.length; i++) {
             var metodoAtual = definirMetodos[i];
-            var eInicializado = metodoAtual.nome.lexema === 'construtor';
-            var funcao = new funcao_1.DeleguaFuncao(metodoAtual.nome.lexema, metodoAtual.funcao, this.ambiente, eInicializado);
-            metodos[metodoAtual.nome.lexema] = funcao;
+            var eInicializado = metodoAtual.simbolo.lexema === 'construtor';
+            var funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, this.ambiente, eInicializado);
+            metodos[metodoAtual.simbolo.lexema] = funcao;
         }
-        var criado = new classe_1.DeleguaClasse(stmt.nome.lexema, superClasse, metodos);
+        var criado = new estruturas_1.DeleguaClasse(declaracao.simbolo.lexema, superClasse, metodos);
         if (superClasse !== null) {
             this.ambiente = this.ambiente.enclosing;
         }
-        this.ambiente.atribuirVariavel(stmt.nome, criado);
+        this.ambiente.atribuirVariavel(declaracao.simbolo, criado);
         return null;
     };
-    Interpretador.prototype.visitarExpressaoObter = function (expr) {
-        var objeto = this.avaliar(expr.objeto);
-        if (objeto instanceof instancia_1.DeleguaInstancia) {
-            return objeto.get(expr.nome) || null;
+    Interpretador.prototype.visitarExpressaoAcessoMetodo = function (expressao) {
+        var objeto = this.avaliar(expressao.objeto);
+        if (objeto instanceof estruturas_1.DeleguaInstancia) {
+            return objeto.get(expressao.simbolo) || null;
         }
         else if (objeto.constructor === Object) {
-            return objeto[expr.nome.lexema] || null;
+            return objeto[expressao.simbolo.lexema] || null;
         }
-        else if (objeto instanceof modulo_1.DeleguaModulo) {
-            return objeto[expr.nome.lexema] || null;
+        else if (objeto instanceof estruturas_1.DeleguaModulo) {
+            return objeto.componentes[expressao.simbolo.lexema] || null;
         }
-        throw new excecoes_1.ErroEmTempoDeExecucao(expr.nome, 'Você só pode acessar métodos do objeto e dicionários.');
+        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Você só pode acessar métodos do objeto e dicionários.', expressao.linha);
     };
-    Interpretador.prototype.visitarExpressaoIsto = function (expr) {
-        return this.procurarVariavel(expr.palavraChave, expr);
+    Interpretador.prototype.visitarExpressaoIsto = function (expressao) {
+        return this.procurarVariavel(expressao.palavraChave, expressao);
     };
-    Interpretador.prototype.visitarExpressaoDicionario = function (expr) {
+    Interpretador.prototype.visitarExpressaoDicionario = function (expressao) {
         var dicionario = {};
-        for (var i = 0; i < expr.chaves.length; i++) {
-            dicionario[this.avaliar(expr.chaves[i])] = this.avaliar(expr.valores[i]);
+        for (var i = 0; i < expressao.chaves.length; i++) {
+            dicionario[this.avaliar(expressao.chaves[i])] = this.avaliar(expressao.valores[i]);
         }
         return dicionario;
     };
-    Interpretador.prototype.visitarExpressaoVetor = function (expr) {
+    Interpretador.prototype.visitarExpressaoVetor = function (expressao) {
         var valores = [];
-        for (var i = 0; i < expr.valores.length; i++) {
-            valores.push(this.avaliar(expr.valores[i]));
+        for (var i = 0; i < expressao.valores.length; i++) {
+            valores.push(this.avaliar(expressao.valores[i]));
         }
         return valores;
     };
-    Interpretador.prototype.visitarExpressaoSuper = function (expr) {
-        var distancia = this.locais.get(expr);
+    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 metodo = superClasse.encontrarMetodo(expr.metodo.lexema);
+        var metodo = superClasse.encontrarMetodo(expressao.metodo.lexema);
         if (metodo === undefined) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.metodo, 'Método chamado indefinido.');
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.metodo, 'Método chamado indefinido.', expressao.linha);
         }
         return metodo.definirEscopo(objeto);
     };
@@ -638,16 +656,17 @@ var Interpretador = /** @class */ (function () {
             return JSON.stringify(objeto);
         return objeto.toString();
     };
-    Interpretador.prototype.executar = function (stmt, mostrarResultado) {
+    Interpretador.prototype.executar = function (declaracao, mostrarResultado) {
         if (mostrarResultado === void 0) { mostrarResultado = false; }
-        var resultado = stmt.aceitar(this);
+        var resultado = declaracao.aceitar(this);
         if (mostrarResultado) {
             console.log(this.paraTexto(resultado));
         }
     };
-    Interpretador.prototype.interpretar = function (declaracoes) {
+    Interpretador.prototype.interpretar = function (objeto) {
         var inicioInterpretacao = perf_hooks_1.performance.now();
         try {
+            var declaracoes = objeto.declaracoes || objeto;
             if (declaracoes.length === 1) {
                 var eObjetoExpressao = declaracoes[0].constructor.name === 'Expressao';
                 if (eObjetoExpressao) {