@designliquido/delegua 0.0.2 → 0.1.0

package/src/{resolver.js → resolvedor/index.ts}

@@ -1,49 +1,22 @@
-class ResolverError extends Error {
-    constructor(mensagem) {
-        super(mensagem);
-        this.mensagem = mensagem;
-    }
-}
-
-class Stack {
-    constructor() {
-        this.stack = [];
-    }
-
-    push(item) {
-        this.stack.push(item);
-    }
-
-    isEmpty() {
-        return this.stack.length === 0;
-    }
+import { ResolvedorInterface } from "../interfaces/resolvedor-interface";
+import { Pilha } from "./Pilha";
+import { ResolverError } from "./ResolverError";
 
-    peek() {
-        if (this.isEmpty()) throw new Error("Pilha vazia.");
-        return this.stack[this.stack.length - 1];
-    }
-
-    pop() {
-        if (this.isEmpty()) throw new Error("Pilha vazia.");
-        return this.stack.pop();
-    }
-}
-
-const FunctionType = {
-    NONE: "NONE",
+const TipoFuncao = {
+    NENHUM: "NENHUM",
     FUNCAO: "FUNCAO",
     CONSTRUTOR: "CONSTRUTOR",
-    METHOD: "METHOD"
+    METODO: "METODO"
 };
 
-const ClassType = {
-    NONE: "NONE",
+const TipoClasse = {
+    NENHUM: "NENHUM",
     CLASSE: "CLASSE",
-    SUBCLASS: "SUBCLASS"
+    SUBCLASSE: "SUBCLASSE"
 };
 
 const LoopType = {
-    NONE: "NONE",
+    NENHUM: "NENHUM",
     ENQUANTO: "ENQUANTO",
     ESCOLHA: "ESCOLHA",
     PARA: "PARA",
@@ -56,70 +29,79 @@ const LoopType = {
  * Exemplo: uma classe A declara dois métodos chamados M e N. Todas as variáveis declaradas dentro de M não podem ser vistas por N, e vice-versa.
  * No entanto, todas as variáveis declaradas dentro da classe A podem ser vistas tanto por M quanto por N.
  */
-module.exports = class Resolver {
-    constructor(interpretador, Delegua) {
+export class Resolver implements ResolvedorInterface {
+    interpretador: any;
+    Delegua: any;
+    escopos: any;
+    FuncaoAtual: any;
+    ClasseAtual: any;
+    cicloAtual: any;
+
+    constructor(Delegua: any, interpretador: any) {
         this.interpretador = interpretador;
         this.Delegua = Delegua;
-        this.escopos = new Stack();
+        this.escopos = new Pilha();
 
-        this.FuncaoAtual = FunctionType.NONE;
-        this.ClasseAtual = ClassType.NONE;
-        this.cicloAtual = ClassType.NONE;
+        this.FuncaoAtual = TipoFuncao.NENHUM;
+        this.ClasseAtual = TipoClasse.NENHUM;
+        this.cicloAtual = TipoClasse.NENHUM;
     }
 
-    definir(nome) {
-        if (this.escopos.isEmpty()) return;
-        this.escopos.peek()[nome.lexeme] = true;
+    definir(nome: any): void {
+        if (this.escopos.eVazio()) return;
+        this.escopos.peek()[nome.lexema] = true;
     }
 
-    declarar(nome) {
-        if (this.escopos.isEmpty()) return;
+    declarar(nome: any): void {
+        if (this.escopos.eVazio()) return;
         let escopo = this.escopos.peek();
-        if (escopo.hasOwnProperty(nome.lexeme))
+        if (escopo.hasOwnProperty(nome.lexema))
             this.Delegua.erro(
                 nome,
                 "Variável com esse nome já declarada neste escopo."
             );
-            escopo[nome.lexeme] = false;
+        escopo[nome.lexema] = false;
     }
 
-    inicioDoEscopo() {
-        this.escopos.push({});
+    inicioDoEscopo(): void {
+        this.escopos.empilhar({});
     }
 
-    finalDoEscopo() {
-        this.escopos.pop();
+    finalDoEscopo(): void {
+        this.escopos.removerUltimo();
     }
 
-    resolver(declaracoes) {
+    resolver(declaracoes: any): void {
         if (Array.isArray(declaracoes)) {
             for (let i = 0; i < declaracoes.length; i++) {
-                declaracoes[i].aceitar(this);
+                if (declaracoes[i] && declaracoes[i].aceitar) {
+                    declaracoes[i].aceitar(this);
+                }
             }
-        } else {
+        } else if (declaracoes) {
             declaracoes.aceitar(this);
         }
     }
 
-    resolverLocal(expr, nome) {
-        for (let i = this.escopos.stack.length - 1; i >= 0; i--) {
-            if (this.escopos.stack[i].hasOwnProperty(nome.lexeme)) {                
-                this.interpretador.resolver(expr, this.escopos.stack.length - 1 - i);
+    resolverLocal(expr: any, nome: any): void {
+        for (let i = this.escopos.pilha.length - 1; i >= 0; i--) {
+            if (this.escopos.pilha[i].hasOwnProperty(nome.lexema)) {
+                this.interpretador.resolver(expr, this.escopos.pilha.length - 1 - i);
             }
         }
     }
 
-    visitBlockStmt(stmt) {
+    visitBlockStmt(stmt: any) : any {
         this.inicioDoEscopo();
         this.resolver(stmt.declaracoes);
         this.finalDoEscopo();
         return null;
     }
 
-    visitVariableExpr(expr) {
+    visitVariableExpr(expr: any): any {
         if (
-            !this.escopos.isEmpty() &&
-            this.escopos.peek()[expr.nome.lexeme] === false
+            !this.escopos.eVazio() &&
+            this.escopos.peek()[expr.nome.lexema] === false
         ) {
             throw new ResolverError(
                 "Não é possível ler a variável local em seu próprio inicializador."
@@ -129,7 +111,7 @@ module.exports = class Resolver {
         return null;
     }
 
-    visitVarStmt(stmt) {
+    visitVarStmt(stmt: any): any {
         this.declarar(stmt.nome);
         if (stmt.inicializador !== null) {
             this.resolver(stmt.inicializador);
@@ -138,42 +120,46 @@ module.exports = class Resolver {
         return null;
     }
 
-    visitAssignExpr(expr) {
+    visitAssignExpr(expr: any): any {
         this.resolver(expr.valor);
         this.resolverLocal(expr, expr.nome);
         return null;
     }
 
-    resolverFuncao(funcao, funcType) {
+    resolverFuncao(funcao: any, funcType: any): void {
         let enclosingFunc = this.FuncaoAtual;
         this.FuncaoAtual = funcType;
 
         this.inicioDoEscopo();
         let parametros = funcao.parametros;
-        for (let i = 0; i < parametros.length; i++) {
-            this.declarar(parametros[i]["nome"]);
-            this.definir(parametros[i]["nome"]);
+
+        if (parametros && parametros.length > 0) {
+            for (let i = 0; i < parametros.length; i++) {
+                this.declarar(parametros[i]["nome"]);
+                this.definir(parametros[i]["nome"]);
+            }
         }
-        this.resolver(funcao.corpo);
+
+        this.resolver(funcao.funcao);
         this.finalDoEscopo();
 
         this.FuncaoAtual = enclosingFunc;
     }
 
-    visitFunctionStmt(stmt) {
+    visitFunctionStmt(stmt: any): any {
         this.declarar(stmt.nome);
         this.definir(stmt.nome);
 
-        this.resolverFuncao(stmt.funcao, FunctionType.FUNCAO);
+        this.resolverFuncao(stmt.funcao, TipoFuncao.FUNCAO);
         return null;
     }
 
-    visitFunctionExpr(stmt) {
-        this.resolverFuncao(stmt, FunctionType.FUNCAO);
+    visitFunctionExpr(stmt: any): any {
+        this.resolverFuncao(stmt, TipoFuncao.FUNCAO);
         return null;
     }
 
-    visitTryStmt(stmt) {
+    visitTryStmt(stmt: any): any {
         this.resolver(stmt.tryBranch);
 
         if (stmt.catchBranch !== null) this.resolver(stmt.catchBranch);
@@ -181,22 +167,22 @@ module.exports = class Resolver {
         if (stmt.finallyBranch !== null) this.resolver(stmt.finallyBranch);
     }
 
-    visitClassStmt(stmt) {
+    visitClassStmt(stmt: any): any {
         let enclosingClass = this.ClasseAtual;
-        this.ClasseAtual = ClassType.CLASSE;
+        this.ClasseAtual = TipoClasse.CLASSE;
 
         this.declarar(stmt.nome);
         this.definir(stmt.nome);
 
         if (
             stmt.superClasse !== null &&
-            stmt.nome.lexeme === stmt.superClasse.nome.lexeme
+            stmt.nome.lexema === stmt.superClasse.nome.lexema
         ) {
             this.Delegua.error("Uma classe não pode herdar de si mesma.");
         }
 
         if (stmt.superClasse !== null) {
-            this.ClasseAtual = ClassType.SUBCLASS;
+            this.ClasseAtual = TipoClasse.SUBCLASSE;
             this.resolver(stmt.superClasse);
         }
 
@@ -210,10 +196,10 @@ module.exports = class Resolver {
 
         let metodos = stmt.metodos;
         for (let i = 0; i < metodos.length; i++) {
-            let declaracao = FunctionType.METHOD;
+            let declaracao = TipoFuncao.METODO;
 
-            if (metodos[i].nome.lexeme === "isto") {
-                declaracao = FunctionType.CONSTRUTOR;
+            if (metodos[i].nome.lexema === "isto") {
+                declaracao = TipoFuncao.CONSTRUTOR;
             }
 
             this.resolverFuncao(metodos[i].funcao, declaracao);
@@ -227,10 +213,10 @@ module.exports = class Resolver {
         return null;
     }
 
-    visitSuperExpr(expr) {
-        if (this.ClasseAtual === ClassType.NONE) {
+    visitSuperExpr(expr: any): any {
+        if (this.ClasseAtual === TipoClasse.NENHUM) {
             this.Delegua.error(expr.palavraChave, "Não pode usar 'super' fora de uma classe.");
-        } else if (this.ClasseAtual !== ClassType.SUBCLASS) {
+        } else if (this.ClasseAtual !== TipoClasse.SUBCLASSE) {
             this.Delegua.error(
                 expr.palavraChave,
                 "Não se usa 'super' numa classe sem SuperClasse."
@@ -241,17 +227,17 @@ module.exports = class Resolver {
         return null;
     }
 
-    visitGetExpr(expr) {
+    visitGetExpr(expr: any): any {
         this.resolver(expr.objeto);
         return null;
     }
 
-    visitExpressionStmt(stmt) {
+    visitExpressionStmt(stmt: any): any {
         this.resolver(stmt.expressao);
         return null;
     }
 
-    visitIfStmt(stmt) {
+    visitIfStmt(stmt: any): any {
         this.resolver(stmt.condicao);
         this.resolver(stmt.thenBranch);
 
@@ -264,20 +250,21 @@ module.exports = class Resolver {
         return null;
     }
 
-    visitImportStmt(stmt) {
+    visitImportStmt(stmt: any): void {
         this.resolver(stmt.caminho);
     }
 
-    visitPrintStmt(stmt) {
+    visitPrintStmt(stmt: any): void {
         this.resolver(stmt.expressao);
     }
 
-    visitReturnStmt(stmt) {
-        if (this.FuncaoAtual === FunctionType.NONE) {
+    visitReturnStmt(stmt: any): any {
+        if (this.FuncaoAtual === TipoFuncao.NENHUM) {
             this.Delegua.error(stmt.palavraChave, "Não é possível retornar do código do escopo superior.");
         }
+
         if (stmt.valor !== null) {
-            if (this.FuncaoAtual === FunctionType.CONSTRUTOR) {
+            if (this.FuncaoAtual === TipoFuncao.CONSTRUTOR) {
                 this.Delegua.error(
                     stmt.palavraChave,
                     "Não pode retornar o valor do construtor."
@@ -288,7 +275,7 @@ module.exports = class Resolver {
         return null;
     }
 
-    visitSwitchStmt(stmt) {
+    visitSwitchStmt(stmt: any): void {
         let enclosingType = this.cicloAtual;
         this.cicloAtual = LoopType.ESCOLHA;
 
@@ -304,13 +291,13 @@ module.exports = class Resolver {
         this.cicloAtual = enclosingType;
     }
 
-    visitWhileStmt(stmt) {
+    visitWhileStmt(stmt: any): any {
         this.resolver(stmt.condicao);
         this.resolver(stmt.corpo);
         return null;
     }
 
-    visitForStmt(stmt) {
+    visitForStmt(stmt: any): any {
         if (stmt.inicializador !== null) {
             this.resolver(stmt.inicializador);
         }
@@ -329,7 +316,7 @@ module.exports = class Resolver {
         return null;
     }
 
-    visitDoStmt(stmt) {
+    visitDoStmt(stmt: any): any {
         this.resolver(stmt.whileCondition);
 
         let enclosingType = this.cicloAtual;
@@ -339,13 +326,13 @@ module.exports = class Resolver {
         return null;
     }
 
-    visitBinaryExpr(expr) {
+    visitBinaryExpr(expr: any): any {
         this.resolver(expr.esquerda);
         this.resolver(expr.direita);
         return null;
     }
 
-    visitCallExpr(expr) {
+    visitCallExpr(expr: any): any {
         this.resolver(expr.callee);
 
         let argumentos = expr.argumentos;
@@ -356,12 +343,12 @@ module.exports = class Resolver {
         return null;
     }
 
-    visitGroupingExpr(expr) {
+    visitGroupingExpr(expr: any): any {
         this.resolver(expr.expressao);
         return null;
     }
 
-    visitDictionaryExpr(expr) {
+    visitDictionaryExpr(expr: any): any {
         for (let i = 0; i < expr.chaves.length; i++) {
             this.resolver(expr.chaves[i]);
             this.resolver(expr.valores[i]);
@@ -369,54 +356,54 @@ module.exports = class Resolver {
         return null;
     }
 
-    visitArrayExpr(expr) {
+    visitArrayExpr(expr: any): any {
         for (let i = 0; i < expr.valores.length; i++) {
             this.resolver(expr.valores[i]);
         }
         return null;
     }
 
-    visitSubscriptExpr(expr) {
+    visitSubscriptExpr(expr: any): any {
         this.resolver(expr.callee);
         this.resolver(expr.indice);
         return null;
     }
 
-    visitContinueStmt(stmt) {
+    visitContinueStmt(stmt?: any): any {
         return null;
     }
 
-    visitBreakStmt(stmt) {
+    visitBreakStmt(stmt?: any): any {
         return null;
     }
 
-    visitAssignsubscriptExpr(expr) {
+    visitAssignsubscriptExpr(expr?: any): any {
         return null;
     }
 
-    visitLiteralExpr(expr) {
+    visitLiteralExpr(expr?: any): any {
         return null;
     }
 
-    visitLogicalExpr(expr) {
+    visitLogicalExpr(expr?: any): any {
         this.resolver(expr.esquerda);
         this.resolver(expr.direita);
         return null;
     }
 
-    visitUnaryExpr(expr) {
+    visitUnaryExpr(expr?: any): any {
         this.resolver(expr.direita);
         return null;
     }
 
-    visitSetExpr(expr) {
+    visitSetExpr(expr?: any): any {
         this.resolver(expr.valor);
         this.resolver(expr.objeto);
         return null;
     }
 
-    visitThisExpr(expr) {
-        if (this.ClasseAtual == ClassType.NONE) {
+    visitThisExpr(expr?: any): any {
+        if (this.ClasseAtual == TipoClasse.NENHUM) {
             this.Delegua.error(expr.palavraChave, "Não pode usar 'isto' fora da classe.");
         }
         this.resolverLocal(expr, expr.palavraChave);

package/src/{tiposDeSimbolos.js → tiposDeSimbolos.ts}

@@ -1,24 +1,30 @@
-module.exports = {
-    NEGACAO: "NEGACAO",
-    DIFERENTE: "DIFERENTE",
+export default {
+    ADICAO: "ADICAO",
     BIT_AND: "BIT_AND",
     BIT_OR: "BIT_OR",
     BIT_XOR: "BIT_XOR",
     BIT_NOT: "BIT_NOT",
     CASO: "CASO",
+    CHAVE_DIREITA: "CHAVE_DIREITA",
+    CHAVE_ESQUERDA: "CHAVE_ESQUERDA",
     CLASSE: "CLASSE",
-    COLON: "COLON",
+    COLCHETE_DIREITO: "COLCHETE_DIREITO",
+    COLCHETE_ESQUERDO: "COLCHETE_ESQUERDO",
     COMMA: "COMMA",
     CONTINUA: "CONTINUA",
+    DIFERENTE: "DIFERENTE",
+    DIVISAO: "DIVISAO",
+    DOIS_PONTOS: "DOIS_PONTOS",
     DOT: "DOT",
     E: "E",
     EM: "EM",
     ENQUANTO: "ENQUANTO",
     EOF: "EOF",
-    IGUAL: "IGUAL",
-    IGUAL_IGUAL: "IGUAL_IGUAL",
     ESCOLHA: "ESCOLHA",
     ESCREVA: "ESCREVA",
+    EXPONENCIACAO: "EXPONENCIACAO",
+    IGUAL: "IGUAL",
+    IGUAL_IGUAL: "IGUAL_IGUAL",
     FALSO: "FALSO",
     FAZER: "FAZER",
     FINALMENTE: "FINALMENTE",
@@ -30,38 +36,31 @@ module.exports = {
     IDENTIFICADOR: "IDENTIFICADOR",
     IMPORTAR: "IMPORTAR",
     ISTO: "ISTO",
-    CHAVE_ESQUERDA: "CHAVE_ESQUERDA",
-    PARENTESE_ESQUERDO: "PARENTESE_ESQUERDO",
-    COLCHETE_ESQUERDO: "COLCHETE_ESQUERDO",
     MENOR: "MENOR",
     MENOR_IGUAL: "MENOR_IGUAL",
     MENOR_MENOR: "MENOR_MENOR",
     MAIS_IGUAL: "MAIS_IGUAL",
-    MENOR_IGUAL: "MENOR_IGUAL",
-    SUBTRACAO: "SUBTRACAO",
-    MODULUS: "MODULUS",
+    MODULO: "MODULO",
+    MULTIPLICACAO: "MULTIPLICACAO",
+    NEGACAO: "NEGACAO",
     NULO: "NULO",
     NUMERO: "NUMERO",
     OU: "OU",
     PADRAO: "PADRAO",
     PARA: "PARA",
+    PARENTESE_DIREITO: "PARENTESE_DIREITO",
+    PARENTESE_ESQUERDO: "PARENTESE_ESQUERDO",
     PAUSA: "PAUSA",
     PEGUE: "PEGUE",
-    ADICAO: "ADICAO",
+    PONTO_E_VIRGULA: "PONTO_E_VIRGULA",
     RETORNA: "RETORNA",
-    PARENTESE_DIREITO: "PARENTESE_DIREITO",
-    CHAVE_DIREITA: "CHAVE_DIREITA",
-    COLCHETE_DIREITO: "COLCHETE_DIREITO",
-    SEMICOLON: "SEMICOLON",
-    SLASH: "SLASH",
-    STAR: "STAR",
-    STAR_STAR: "STAR_STAR",
-    TEXTO: "TEXTO",
+    SUBTRACAO: "SUBTRACAO",
     SE: "SE",
     SENAO: "SENAO",
     SENAOSE: "SENAOSE",
     SUPER: "SUPER",
-    TENTE: "TENTE",    
+    TENTE: "TENTE",
+    TEXTO: "TEXTO",
     VAR: "VAR",
     VERDADEIRO: "VERDADEIRO"
 };

package/src/web.ts

@@ -0,0 +1,75 @@
+import { Lexer } from "./lexador";
+import { Parser } from "./avaliador-sintatico";
+import { Resolver } from "./resolvedor";
+import { Interpretador } from "./interpretador";
+import tiposDeSimbolos from "./tiposDeSimbolos";
+
+export class Delegua {
+  nomeArquivo: any;
+
+  teveErro: any;
+  teveErroEmTempoDeExecucao: any;
+
+  constructor(nomeArquivo) {
+    this.nomeArquivo = nomeArquivo;
+
+    this.teveErro = false;
+    this.teveErroEmTempoDeExecucao = false;
+  }
+
+  runBlock(codigo: any) {
+    const interpretador = new Interpretador(this, process.cwd());
+
+    const lexer = new Lexer(this);
+    const simbolos = lexer.scan(codigo);
+
+    if (this.teveErro === true) return;
+
+    const analisar = new Parser(this);
+    const declaracoes = analisar.analisar(simbolos);
+
+    if (this.teveErro === true) return;
+
+    const resolver = new Resolver(this, interpretador);
+    resolver.resolver(declaracoes);
+
+    if (this.teveErro === true) return;
+
+    interpretador.interpretar(declaracoes);
+  }
+
+  reportar(linha: any, onde: any, mensagem: any) {
+    if (this.nomeArquivo)
+      console.error(
+        `[Arquivo: ${this.nomeArquivo}] [Linha: ${linha}] Erro${onde}: ${mensagem}`
+      );
+    else console.error(`[Linha: ${linha}] Erro${onde}: ${mensagem}`);
+    this.teveErro = true;
+  }
+
+  erro(simbolo: any, mensagemDeErro: any) {
+    if (simbolo.tipo === tiposDeSimbolos.EOF) {
+      this.reportar(simbolo.line, " no final", mensagemDeErro);
+    } else {
+      this.reportar(simbolo.line, ` no '${simbolo.lexema}'`, mensagemDeErro);
+    }
+  }
+
+  lexerError(linha, caractere, mensagem) {
+    this.reportar(linha, ` no '${caractere}'`, mensagem);
+  }
+
+  erroEmTempoDeExecucao(erro) {
+    const linha = erro.simbolo.linha;
+    if (erro.simbolo && linha) {
+      if (this.nomeArquivo)
+        console.error(
+          `Erro: [Arquivo: ${this.nomeArquivo}] [Linha: ${erro.simbolo.linha}] ${erro.mensagem}`
+        );
+      else console.error(`Erro: [Linha: ${erro.simbolo.linha}] ${erro.mensagem}`);
+    } else {
+      console.error(`Erro: ${erro.mensagem}`);
+    }
+    this.teveErroEmTempoDeExecucao = true;
+  }
+};

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+    "compilerOptions": {
+        "outDir": "dist",
+        "module": "commonjs",
+        "target": "ES5",
+        "rootDir": ".",
+        "allowJs": true,
+        "sourceMap": true
+    },
+    "exclude": ["babel.config.js", "dist/**/*"]
+}

package/indice.js

@@ -1,14 +0,0 @@
-const Delegua = require("./src/delegua.js").Delegua;
-
-const principal = function() {
-    const argumentos = process.argv;
-
-    const delegua = new Delegua();
-    if (argumentos.length === 2) {
-        delegua.runPrompt();
-    } else {
-        delegua.runfile(argumentos[2]);
-    }
-};
-
-principal();