@designliquido/delegua 0.0.1 → 0.0.2

package/src/lexer.js

@@ -1,38 +1,38 @@
-const tokenTypes = require("./tokenTypes.js");
+const tiposDeSimbolos = require("./tiposDeSimbolos.js");
 
 const palavrasReservadas = {
-    e: tokenTypes.E,
-    em: tokenTypes.EM,
-    classe: tokenTypes.CLASSE,
-    senao: tokenTypes.SENAO,
-    falso: tokenTypes.FALSO,
-    para: tokenTypes.PARA,
-    funcao: tokenTypes.FUNCAO,
-    se: tokenTypes.SE,
-    senaose: tokenTypes.SENAOSE,
-    nulo: tokenTypes.NULO,
-    ou: tokenTypes.OU,
-    escreva: tokenTypes.ESCREVA,
-    retorna: tokenTypes.RETORNA,
-    super: tokenTypes.SUPER,
-    isto: tokenTypes.ISTO,
-    verdadeiro: tokenTypes.VERDADEIRO,
-    var: tokenTypes.VAR,
-    fazer: tokenTypes.FAZER,
-    enquanto: tokenTypes.ENQUANTO,
-    pausa: tokenTypes.PAUSA,
-    continua: tokenTypes.CONTINUA,
-    escolha: tokenTypes.ESCOLHA,
-    caso: tokenTypes.CASO,
-    padrao: tokenTypes.PADRAO,
-    importar: tokenTypes.IMPORTAR,
-    tente: tokenTypes.TENTE,
-    pegue: tokenTypes.PEGUE,
-    finalmente: tokenTypes.FINALMENTE,
-    herda: tokenTypes.HERDA
+    e: tiposDeSimbolos.E,
+    em: tiposDeSimbolos.EM,
+    classe: tiposDeSimbolos.CLASSE,
+    senao: tiposDeSimbolos.SENAO,
+    falso: tiposDeSimbolos.FALSO,
+    para: tiposDeSimbolos.PARA,
+    funcao: tiposDeSimbolos.FUNCAO,
+    se: tiposDeSimbolos.SE,
+    senaose: tiposDeSimbolos.SENAOSE,
+    nulo: tiposDeSimbolos.NULO,
+    ou: tiposDeSimbolos.OU,
+    escreva: tiposDeSimbolos.ESCREVA,
+    retorna: tiposDeSimbolos.RETORNA,
+    super: tiposDeSimbolos.SUPER,
+    isto: tiposDeSimbolos.ISTO,
+    verdadeiro: tiposDeSimbolos.VERDADEIRO,
+    var: tiposDeSimbolos.VAR,
+    fazer: tiposDeSimbolos.FAZER,
+    enquanto: tiposDeSimbolos.ENQUANTO,
+    pausa: tiposDeSimbolos.PAUSA,
+    continua: tiposDeSimbolos.CONTINUA,
+    escolha: tiposDeSimbolos.ESCOLHA,
+    caso: tiposDeSimbolos.CASO,
+    padrao: tiposDeSimbolos.PADRAO,
+    importar: tiposDeSimbolos.IMPORTAR,
+    tente: tiposDeSimbolos.TENTE,
+    pegue: tiposDeSimbolos.PEGUE,
+    finalmente: tiposDeSimbolos.FINALMENTE,
+    herda: tiposDeSimbolos.HERDA
 };
 
-class Token {
+class Simbolo {
     constructor(tipo, lexeme, literal, linha) {
         this.tipo = tipo;
         this.lexeme = lexeme;
@@ -52,8 +52,8 @@ class Token {
  * estruturas, tais como nomes de variáveis, funções, literais, classes e assim por diante.
  */
 module.exports = class Lexer {
-    constructor(codigo, Egua) {
-        this.Egua = Egua;
+    constructor(codigo, Delegua) {
+        this.Delegua = Delegua;
         this.codigo = codigo;
 
         this.simbolos = [];
@@ -63,19 +63,19 @@ module.exports = class Lexer {
         this.linha = 1;
     }
 
-    eDigito(c) {
-        return c >= "0" && c <= "9";
+    eDigito(caractere) {
+        return caractere >= "0" && caractere <= "9";
     }
 
-    eAlfabeto(c) {
-        return (c >= "a" && c <= "z") || (c >= "A" && c <= "Z") || c == "_";
+    eAlfabeto(caractere) {
+        return (caractere >= "a" && caractere <= "z") || (caractere >= "A" && caractere <= "Z") || caractere == "_";
     }
 
-    eAlfabetoOuDigito(c) {
-        return this.eDigito(c) || this.eAlfabeto(c);
+    eAlfabetoOuDigito(caractere) {
+        return this.eDigito(caractere) || this.eAlfabeto(caractere);
     }
 
-    endOfCode() {
+    eFinalDoCodigo() {
         return this.atual >= this.codigo.length;
     }
 
@@ -86,11 +86,11 @@ module.exports = class Lexer {
 
     adicionarSimbolo(tipo, literal = null) {
         const texto = this.codigo.substring(this.inicio, this.atual);
-        this.simbolos.push(new Token(tipo, texto, literal, this.linha));
+        this.simbolos.push(new Simbolo(tipo, texto, literal, this.linha));
     }
 
     match(esperado) {
-        if (this.endOfCode()) {
+        if (this.eFinalDoCodigo()) {
             return false;
         }
 
@@ -103,7 +103,7 @@ module.exports = class Lexer {
     }
 
     peek() {
-        if (this.endOfCode()) return "\0";
+        if (this.eFinalDoCodigo()) return "\0";
         return this.codigo.charAt(this.atual);
     }
 
@@ -116,14 +116,14 @@ module.exports = class Lexer {
         return this.codigo.charAt(this.atual - 1);
     }
 
-    analisarTexto(stringChar = '"') {
-        while (this.peek() !== stringChar && !this.endOfCode()) {
+    analisarTexto(texto = '"') {
+        while (this.peek() !== texto && !this.eFinalDoCodigo()) {
             if (this.peek() === "\n") this.linha = +1;
             this.avancar();
         }
 
-        if (this.endOfCode()) {
-            this.Egua.lexerError(
+        if (this.eFinalDoCodigo()) {
+            this.Delegua.lexerError(
                 this.linha,
                 this.voltar(),
                 "Texto não finalizado."
@@ -134,7 +134,7 @@ module.exports = class Lexer {
         this.avancar();
 
         const valor = this.codigo.substring(this.inicio + 1, this.atual - 1);
-        this.adicionarSimbolo(tokenTypes.STRING, valor);
+        this.adicionarSimbolo(tiposDeSimbolos.TEXTO, valor);
     }
 
     analisarNumero() {
@@ -151,7 +151,7 @@ module.exports = class Lexer {
         }
 
         const numeroCompleto = this.codigo.substring(this.inicio, this.atual);
-        this.adicionarSimbolo(tokenTypes.NUMBER, parseFloat(numeroCompleto));
+        this.adicionarSimbolo(tiposDeSimbolos.NUMERO, parseFloat(numeroCompleto));
     }
 
     identificarPalavraChave() {
@@ -159,121 +159,121 @@ module.exports = class Lexer {
             this.avancar();
         }
 
-        const c = this.codigo.substring(this.inicio, this.atual);
-        const tipo = c in palavrasReservadas ? palavrasReservadas[c] : tokenTypes.IDENTIFIER;
+        const codigo = this.codigo.substring(this.inicio, this.atual);
+        const tipo = codigo in palavrasReservadas ? palavrasReservadas[codigo] : tiposDeSimbolos.IDENTIFICADOR;
 
         this.adicionarSimbolo(tipo);
     }
 
     scanToken() {
-        const char = this.avancar();
+        const caractere = this.avancar();
 
-        switch (char) {
+        switch (caractere) {
             case "[":
-                this.adicionarSimbolo(tokenTypes.LEFT_SQUARE_BRACKET);
+                this.adicionarSimbolo(tiposDeSimbolos.COLCHETE_ESQUERDO);
                 break;
             case "]":
-                this.adicionarSimbolo(tokenTypes.RIGHT_SQUARE_BRACKET);
+                this.adicionarSimbolo(tiposDeSimbolos.COLCHETE_DIREITO);
                 break;
             case "(":
-                this.adicionarSimbolo(tokenTypes.LEFT_PAREN);
+                this.adicionarSimbolo(tiposDeSimbolos.PARENTESE_ESQUERDO);
                 break;
             case ")":
-                this.adicionarSimbolo(tokenTypes.RIGHT_PAREN);
+                this.adicionarSimbolo(tiposDeSimbolos.PARENTESE_DIREITO);
                 break;
             case "{":
-                this.adicionarSimbolo(tokenTypes.LEFT_BRACE);
+                this.adicionarSimbolo(tiposDeSimbolos.CHAVE_ESQUERDA);
                 break;
             case "}":
-                this.adicionarSimbolo(tokenTypes.RIGHT_BRACE);
+                this.adicionarSimbolo(tiposDeSimbolos.CHAVE_DIREITA);
                 break;
             case ",":
-                this.adicionarSimbolo(tokenTypes.COMMA);
+                this.adicionarSimbolo(tiposDeSimbolos.COMMA);
                 break;
             case ".":
-                this.adicionarSimbolo(tokenTypes.DOT);
+                this.adicionarSimbolo(tiposDeSimbolos.DOT);
                 break;
             case "-":
                 if (this.match("=")) {
-                    this.adicionarSimbolo(tokenTypes.MENOR_IGUAL);
+                    this.adicionarSimbolo(tiposDeSimbolos.MENOR_IGUAL);
                 }
-                this.adicionarSimbolo(tokenTypes.MINUS);
+                this.adicionarSimbolo(tiposDeSimbolos.SUBTRACAO);
                 break;
             case "+":
                 if (this.match("=")) {
-                    this.adicionarSimbolo(tokenTypes.MAIS_IGUAL);
+                    this.adicionarSimbolo(tiposDeSimbolos.MAIS_IGUAL);
                 }
-                this.adicionarSimbolo(tokenTypes.PLUS);
+                this.adicionarSimbolo(tiposDeSimbolos.ADICAO);
                 break;
             case ":":
-                this.adicionarSimbolo(tokenTypes.COLON);
+                this.adicionarSimbolo(tiposDeSimbolos.COLON);
                 break;
             case ";":
-                this.adicionarSimbolo(tokenTypes.SEMICOLON);
+                this.adicionarSimbolo(tiposDeSimbolos.SEMICOLON);
                 break;
             case "%":
-                this.adicionarSimbolo(tokenTypes.MODULUS);
+                this.adicionarSimbolo(tiposDeSimbolos.MODULUS);
                 break;
             case "*":
                 if (this.peek() === "*") {
                     this.avancar();
-                    this.adicionarSimbolo(tokenTypes.STAR_STAR);
+                    this.adicionarSimbolo(tiposDeSimbolos.STAR_STAR);
                     break;
                 }
-                this.adicionarSimbolo(tokenTypes.STAR);
+                this.adicionarSimbolo(tiposDeSimbolos.STAR);
                 break;
             case "!":
                 this.adicionarSimbolo(
-                    this.match("=") ? tokenTypes.BANG_EQUAL : tokenTypes.BANG
+                    this.match("=") ? tiposDeSimbolos.DIFERENTE : tiposDeSimbolos.NEGACAO
                 );
                 break;
             case "=":
                 this.adicionarSimbolo(
-                    this.match("=") ? tokenTypes.EQUAL_EQUAL : tokenTypes.EQUAL
+                    this.match("=") ? tiposDeSimbolos.IGUAL_IGUAL : tiposDeSimbolos.IGUAL
                 );
                 break;
 
             case "&":
-                this.adicionarSimbolo(tokenTypes.BIT_AND);
+                this.adicionarSimbolo(tiposDeSimbolos.BIT_AND);
                 break;
 
             case "~":
-                this.adicionarSimbolo(tokenTypes.BIT_NOT);
+                this.adicionarSimbolo(tiposDeSimbolos.BIT_NOT);
                 break;
 
             case "|":
-                this.adicionarSimbolo(tokenTypes.BIT_OR);
+                this.adicionarSimbolo(tiposDeSimbolos.BIT_OR);
                 break;
 
             case "^":
-                this.adicionarSimbolo(tokenTypes.BIT_XOR);
+                this.adicionarSimbolo(tiposDeSimbolos.BIT_XOR);
                 break;
 
             case "<":
                 if (this.match("=")) {
-                    this.adicionarSimbolo(tokenTypes.LESS_EQUAL);
+                    this.adicionarSimbolo(tiposDeSimbolos.MENOR_IGUAL);
                 } else if (this.match("<")) {
-                    this.adicionarSimbolo(tokenTypes.LESSER_LESSER);
+                    this.adicionarSimbolo(tiposDeSimbolos.MENOR_MENOR);
                 } else {
-                    this.adicionarSimbolo(tokenTypes.LESS);
+                    this.adicionarSimbolo(tiposDeSimbolos.MENOR);
                 }
                 break;
 
             case ">":
                 if (this.match("=")) {
-                    this.adicionarSimbolo(tokenTypes.GREATER_EQUAL);
+                    this.adicionarSimbolo(tiposDeSimbolos.MAIOR_IGUAL);
                 } else if (this.match(">")) {
-                    this.adicionarSimbolo(tokenTypes.GREATER_GREATER);
+                    this.adicionarSimbolo(tiposDeSimbolos.MAIOR_MAIOR);
                 } else {
-                    this.adicionarSimbolo(tokenTypes.GREATER);
+                    this.adicionarSimbolo(tiposDeSimbolos.MAIOR);
                 }
                 break;
 
             case "/":
                 if (this.match("/")) {
-                    while (this.peek() != "\n" && !this.endOfCode()) this.avancar();
+                    while (this.peek() != "\n" && !this.eFinalDoCodigo()) this.avancar();
                 } else {
-                    this.adicionarSimbolo(tokenTypes.SLASH);
+                    this.adicionarSimbolo(tiposDeSimbolos.SLASH);
                 }
                 break;
 
@@ -297,19 +297,20 @@ module.exports = class Lexer {
                 break;
 
             default:
-                if (this.eDigito(char)) this.analisarNumero();
-                else if (this.eAlfabeto(char)) this.identificarPalavraChave();
-                else this.Egua.lexerError(this.linha, char, "Caractere inesperado.");
+                if (this.eDigito(caractere)) this.analisarNumero();
+                else if (this.eAlfabeto(caractere)) this.identificarPalavraChave();
+                else this.Delegua.lexerError(this.linha, caractere, "Caractere inesperado.");
         }
     }
 
     scan() {
-        while (!this.endOfCode()) {
+        while (!this.eFinalDoCodigo()) {
             this.inicio = this.atual;
             this.scanToken();
         }
 
-        this.simbolos.push(new Token(tokenTypes.EOF, "", null, this.linha));
+        this.simbolos.push(new Simbolo(tiposDeSimbolos.EOF, "", null, this.linha));
+        
         return this.simbolos;
     }
 };

package/src/lib/globalLib.js

@@ -1,27 +1,27 @@
-const RuntimeError = require("../errors.js").RuntimeError,
-    EguaFunction = require("../structures/function.js"),
-    EguaInstance = require("../structures/instance.js"),
-    StandardFn = require("../structures/standardFn.js"),
-    EguaClass = require("../structures/class.js");
+const ErroEmTempoDeExecucao = require("../erro.js").ErroEmTempoDeExecucao,
+    DeleguaFuncao = require("../estruturas/funcao.js"),
+    DeleguaInstancia = require("../estruturas/instancia.js"),
+    FuncaoPadrao = require("../estruturas/funcaoPadrao.js"),
+    DeleguaClasse = require("../estruturas/classe.js");
 
 
-module.exports = function (interpreter, globals) {
+module.exports = function (interpretador, globals) {
     // Retorna um número aleatório entre 0 e 1.
-    globals.defineVar(
+    globals.definirVariavel(
         "aleatorio",
-        new StandardFn(1, function () {
+        new FuncaoPadrao(1, function () {
             return Math.random();
         })
     );
 
     // Retorna um número aleatório de acordo com o parâmetro passado.
     // MIN(inclusivo) - MAX(exclusivo)
-    globals.defineVar(
+    globals.definirVariavel(
         "aleatorioEntre",
-        new StandardFn(1, function (min, max) {
+        new FuncaoPadrao(1, function (min, max) {
             if (typeof min !== 'number' || typeof max !== 'number') {
-                throw new RuntimeError(
-                    this.token,
+                throw new ErroEmTempoDeExecucao(
+                    this.simbolo,
                     "Os dois parâmetros devem ser do tipo número."
                 );
             }
@@ -30,49 +30,49 @@ module.exports = function (interpreter, globals) {
         })
     );    
 
-    globals.defineVar(
+    globals.definirVariavel(
         "inteiro",
-        new StandardFn(1, function (value) {
-            if (value === undefined || value === null) {
-                throw new RuntimeError(
-                    this.token,
+        new FuncaoPadrao(1, function (valor) {
+            if (valor === undefined || valor === null) {
+                throw new ErroEmTempoDeExecucao(
+                    this.simbolo,
                     "Somente números podem passar para inteiro."
                 );
             }
 
-            if (!/^-{0,1}\d+$/.test(value) && !/^\d+\.\d+$/.test(value)) {
-                throw new RuntimeError(
-                    this.token,
+            if (!/^-{0,1}\d+$/.test(valor) && !/^\d+\.\d+$/.test(valor)) {
+                throw new ErroEmTempoDeExecucao(
+                    this.simbolo,
                     "Somente números podem passar para inteiro."
                 );
             }
 
-            return parseInt(value);
+            return parseInt(valor);
         })
     );
 
-    globals.defineVar(
+    globals.definirVariavel(
         "mapear",
-        new StandardFn(1, function (array, callback) {
+        new FuncaoPadrao(1, function (array, callback) {
             if (!Array.isArray(array)) {
-                throw new RuntimeError(
-                    this.token,
+                throw new ErroEmTempoDeExecucao(
+                    this.simbolo,
                     "Parâmetro inválido. O primeiro parâmetro da função, deve ser um array."
                 );
             }
 
-            if (callback.constructor.name !== 'EguaFunction') {
-                throw new RuntimeError(
-                    this.token,
+            if (callback.constructor.nome !== 'DeleguaFuncao') {
+                throw new ErroEmTempoDeExecucao(
+                    this.simbolo,
                     "Parâmetro inválido. O segundo parâmetro da função, deve ser uma função."
                 );
             }
 
             let provisorio = [];
-            for (let index = 0; index < array.length; ++index) {
+            for (let indice = 0; indice < array.length; ++indice) {
                 provisorio.push(
                     callback.call(
-                        interpreter, [array[index]]
+                        interpretador, [array[indice]]
                     )
                 );
             }
@@ -81,12 +81,12 @@ module.exports = function (interpreter, globals) {
         })
     );
 
-    globals.defineVar(
+    globals.definirVariavel(
         "ordenar",
-        new StandardFn(1, function (obj) {
+        new FuncaoPadrao(1, function (obj) {
             if (Array.isArray(obj) == false) {
-                throw new RuntimeError(
-                    this.token,
+                throw new ErroEmTempoDeExecucao(
+                    this.simbolo,
                     "Valor Inválido. Objeto inserido não é um vetor."
                 );
             }
@@ -106,66 +106,66 @@ module.exports = function (interpreter, globals) {
         })
     );
 
-    globals.defineVar(
+    globals.definirVariavel(
         "real",
-        new StandardFn(1, function (value) {
-            if (!/^-{0,1}\d+$/.test(value) && !/^\d+\.\d+$/.test(value))
-                throw new RuntimeError(
-                    this.token,
+        new FuncaoPadrao(1, function (valor) {
+            if (!/^-{0,1}\d+$/.test(valor) && !/^\d+\.\d+$/.test(valor))
+                throw new ErroEmTempoDeExecucao(
+                    this.simbolo,
                     "Somente números podem passar para real."
                 );
-            return parseFloat(value);
+            return parseFloat(valor);
         })
     );
 
-    globals.defineVar(
+    globals.definirVariavel(
         "tamanho",
-        new StandardFn(1, function (obj) {
-            if (!isNaN(obj)) {
-                throw new RuntimeError(
-                    this.token,
+        new FuncaoPadrao(1, function (objeto) {
+            if (!isNaN(objeto)) {
+                throw new ErroEmTempoDeExecucao(
+                    this.simbolo,
                     "Não é possível encontrar o tamanho de um número."
                 );
             }
 
-            if (obj instanceof EguaInstance) {
-                throw new RuntimeError(
-                    this.token,
+            if (objeto instanceof DeleguaInstancia) {
+                throw new ErroEmTempoDeExecucao(
+                    this.simbolo,
                     "Você não pode encontrar o tamanho de uma declaração."
                 );
             }
 
-            if (obj instanceof EguaFunction) {
-                return obj.declaration.params.length;
+            if (objeto instanceof DeleguaFuncao) {
+                return objeto.declaracao.parametros.length;
             }
 
-            if (obj instanceof StandardFn) {
-                return obj.arityValue;
+            if (objeto instanceof FuncaoPadrao) {
+                return objeto.valorAridade;
             }
 
-            if (obj instanceof EguaClass) {
-                let methods = obj.methods;
-                let length = 0;
+            if (objeto instanceof DeleguaClasse) {
+                let metodos = objeto.metodos;
+                let tamanho = 0;
 
-                if (methods.init && methods.init.isInitializer) {
-                    length = methods.init.declaration.params.length;
+                if (metodos.init && metodos.init.eInicializador) {
+                    tamanho = metodos.init.declaracao.parametros.length;
                 }
 
-                return length;
+                return tamanho;
             }
 
-            return obj.length;
+            return objeto.length;
         })
     );
 
-    globals.defineVar(
+    globals.definirVariavel(
         "texto",
-        new StandardFn(1, function (value) {
-            return `${value}`;
+        new FuncaoPadrao(1, function (valor) {
+            return `${valor}`;
         })
     );
 
-    globals.defineVar("exports", {});
+    globals.definirVariavel("exports", {});
 
     return globals;
 };

package/src/lib/importStdlib.js

@@ -1,41 +1,32 @@
-const RuntimeError = require("../errors.js").RuntimeError,
-    StandardFn = require("../structures/standardFn.js"),
-    EguaModule = require("../structures/module.js");
+const ErroEmTempoDeExecucao = require("../erro.js").ErroEmTempoDeExecucao,
+    FuncaoPadrao = require("../estruturas/funcaoPadrao.js"),
+    DeleguaModulo = require("../estruturas/modulo.js");
 
-const loadModule = function (moduleName, modulePath) {
-    let moduleData;
+const carregarModulo = function (nomeDoModulo, caminhoDoModulo) {
+    let dadosDoModulo;
     try {
-        moduleData = require(modulePath);
+        dadosDoModulo = require(caminhoDoModulo);
     } catch (erro) {
-        throw new RuntimeError(moduleName, `Biblioteca ${moduleName} não encontrada para importação.`);
+        throw new ErroEmTempoDeExecucao(nomeDoModulo, `Biblioteca ${nomeDoModulo} não encontrada para importação.`);
     }
      
-    let newModule = new EguaModule(moduleName);
+    let novoModulo = new DeleguaModulo(nomeDoModulo);
 
-    let keys = Object.keys(moduleData);
-    for (let i = 0; i < keys.length; i++) {
-        let currentItem = moduleData[keys[i]];
+    let chaves = Object.keys(dadosDoModulo);
+    for (let i = 0; i < chaves.length; i++) {
+        const moduloAtual = dadosDoModulo[chaves[i]];
 
-        if (typeof currentItem === "function") {
-            newModule[keys[i]] = new StandardFn(currentItem.length, currentItem);
+        if (typeof moduloAtual === "function") {
+            novoModulo[chaves[i]] = new FuncaoPadrao(moduloAtual.length, moduloAtual);
         } else {
-            newModule[keys[i]] = currentItem;
+            novoModulo[chaves[i]] = moduloAtual;
         }
     }
 
-    return newModule;
+    return novoModulo;
 };
 
-require("./tempo.js");
-require("./eguamat.js");
-
-module.exports = function (name) {
-    switch (name) {
-        case "tempo":
-            return loadModule("tempo", "./tempo.js");
-        case "eguamat":
-            return loadModule("eguamat", "./eguamat.js");
-        default:
-            return loadModule(name, name);
-    }
+module.exports = function (nome) {
+    //TODO:Samuel: Precisa testar ainda.
+    return carregarModulo(nome, nome);
 };