@designliquido/delegua 0.0.2 → 0.1.0

package/src/{stmt.js → declaracoes/index.ts}

@@ -1,31 +1,39 @@
-class Stmt {
+export class Stmt {
     aceitar(visitor) { }
 }
 
-class Expressao extends Stmt {
+export class Expressao extends Stmt {
+    expressao: any;
+
     constructor(expressao) {
         super();
         this.expressao = expressao;
     }
 
-    aceitar(visitor) {
+    aceitar(visitor: any) {
         return visitor.visitExpressionStmt(this)
     }
 }
 
-class Funcao extends Stmt {
-    constructor(nome, funcao) {
+export class Funcao extends Stmt {
+    nome: string;
+    funcao: any;
+
+    constructor(nome: any, funcao: any) {
         super();
         this.nome = nome;
         this.funcao = funcao;
     }
 
-    aceitar(visitor) {
+    aceitar(visitor: any) {
         return visitor.visitFunctionStmt(this);
     }
 }
 
-class Retorna extends Stmt {
+export class Retorna extends Stmt {
+    palavraChave: string;
+    valor: any;
+
     constructor(palavraChave, valor) {
         super();
         this.palavraChave = palavraChave;
@@ -37,20 +45,26 @@ class Retorna extends Stmt {
     }
 }
 
-class Classe extends Stmt {
-    constructor(nome, superClasse, metodos) {
+export class Classe extends Stmt {
+    nome: string;
+    superClasse: any;
+    metodos: any;
+
+    constructor(nome: any, superClasse: any, metodos: any) {
         super();
         this.nome = nome;
         this.superClasse = superClasse;
         this.metodos = metodos;
     }
 
-    aceitar(visitor) {
+    aceitar(visitor: any) {
         return visitor.visitClassStmt(this);
     }
 }
 
-class Block extends Stmt {
+export class Block extends Stmt {
+    declaracoes: any;
+
     constructor(declaracoes) {
         super();
         this.declaracoes = declaracoes;
@@ -61,7 +75,9 @@ class Block extends Stmt {
     }
 }
 
-class Escreva extends Stmt {
+export class Escreva extends Stmt {
+    expressao: any;
+
     constructor(expressao) {
         super();
         this.expressao = expressao;
@@ -72,7 +88,10 @@ class Escreva extends Stmt {
     }
 }
 
-class Importar extends Stmt {
+export class Importar extends Stmt {
+    caminho: string;
+    closeBracket: any;
+
     constructor(caminho, closeBracket) {
         super();
         this.caminho = caminho;
@@ -84,19 +103,25 @@ class Importar extends Stmt {
     }
 }
 
-class Fazer extends Stmt {
+export class Fazer extends Stmt {
+    doBranch: any;
+    whileCondition: any;
+
     constructor(doBranch, whileCondition) {
-      super();
-      this.doBranch = doBranch;
-      this.whileCondition = whileCondition;
+        super();
+        this.doBranch = doBranch;
+        this.whileCondition = whileCondition;
     }
-  
+
     aceitar(visitor) {
-      return visitor.visitDoStmt(this);
+        return visitor.visitDoStmt(this);
     }
-  }
+}
+
+export class Enquanto extends Stmt {
+    condicao: any;
+    corpo: any;
 
-class Enquanto extends Stmt {
     constructor(condicao, corpo) {
         super();
         this.condicao = condicao;
@@ -108,7 +133,12 @@ class Enquanto extends Stmt {
     }
 }
 
-class Para extends Stmt {
+export class Para extends Stmt {
+    inicializador: any;
+    condicao: any;
+    incrementar: any;
+    corpo: any;
+
     constructor(inicializador, condicao, incrementar, corpo) {
         super();
         this.inicializador = inicializador;
@@ -122,8 +152,13 @@ class Para extends Stmt {
     }
 }
 
-class Tente extends Stmt {
-    constructor(tryBranch, catchBranch, elseBranch, finallyBranch) {
+export class Tente extends Stmt {
+    tryBranch: any;
+    catchBranch: any;
+    elseBranch: any;
+    finallyBranch: any;
+
+    constructor(tryBranch: any, catchBranch: any, elseBranch: any, finallyBranch: any) {
         super();
         this.tryBranch = tryBranch;
         this.catchBranch = catchBranch;
@@ -131,12 +166,17 @@ class Tente extends Stmt {
         this.finallyBranch = finallyBranch;
     }
 
-    aceitar(visitor) {
+    aceitar(visitor: any) {
         return visitor.visitTryStmt(this);
     }
 }
 
-class Se extends Stmt {
+export class Se extends Stmt {
+    condicao: any;
+    thenBranch: any;
+    elifBranches: any;
+    elseBranch: any;
+
     constructor(condicao, thenBranch, elifBranches, elseBranch) {
         super();
         this.condicao = condicao;
@@ -150,7 +190,11 @@ class Se extends Stmt {
     }
 }
 
-class Escolha extends Stmt {
+export class Escolha extends Stmt {
+    condicao: any;
+    branches: any;
+    defaultBranch: any;
+
     constructor(condicao, branches, defaultBranch) {
         super();
         this.condicao = condicao;
@@ -163,7 +207,7 @@ class Escolha extends Stmt {
     }
 }
 
-class Pausa extends Stmt {
+export class Pausa extends Stmt {
     constructor() {
         super();
     }
@@ -173,7 +217,7 @@ class Pausa extends Stmt {
     }
 }
 
-class Continua extends Stmt {
+export class Continua extends Stmt {
     constructor() {
         super();
     }
@@ -183,33 +227,17 @@ class Continua extends Stmt {
     }
 }
 
-class Var extends Stmt {
-    constructor(nome, inicializador) {
+export class Var extends Stmt {
+    nome: any;
+    inicializador: any;
+
+    constructor(nome: any, inicializador: any) {
         super();
         this.nome = nome;
         this.inicializador = inicializador;
     }
 
-    aceitar(visitor) {
+    aceitar(visitor: any) {
         return visitor.visitVarStmt(this);
     }
 }
-
-module.exports = {
-    Expressao,
-    Funcao,
-    Retorna,
-    Classe,
-    Block,
-    Escreva,
-    Importar,
-    Fazer,
-    Enquanto,
-    Para,
-    Tente,
-    Se,
-    Escolha,
-    Pausa,
-    Continua,
-    Var
-};

package/src/delegua.ts

@@ -0,0 +1,156 @@
+import * as fs from "fs";
+import * as caminho from "path";
+import * as readline from "readline";
+
+import { Lexer } from "./lexador";
+import { Parser } from "./avaliador-sintatico";
+import { Resolver } from "./resolvedor";
+import { Interpretador } from "./interpretador";
+import tiposDeSimbolos from "./tiposDeSimbolos";
+
+import { ReturnException } from "./excecoes";
+import { AvaliadorSintaticoInterface, InterpretadorInterface, LexadorInterface } from "./interfaces";
+import { ResolvedorInterface } from "./interfaces/resolvedor-interface";
+import { InterpretadorEguaClassico } from "./interpretador/dialetos/egua-classico";
+import { ResolverEguaClassico } from "./resolvedor/dialetos/egua-classico";
+import { ParserEguaClassico } from "./avaliador-sintatico/dialetos/egua-classico";
+import { LexerEguaClassico } from "./lexador/dialetos/egua-classico";
+
+export class Delegua {
+    nomeArquivo: any;
+    teveErro: any;
+    teveErroEmTempoDeExecucao: any;
+    dialeto: string;
+
+    interpretador: InterpretadorInterface;
+    lexador: LexadorInterface;
+    avaliadorSintatico: AvaliadorSintaticoInterface;
+    resolvedor: ResolvedorInterface;
+
+    constructor(dialeto: string = 'delegua', nomeArquivo?: string) {
+        this.nomeArquivo = nomeArquivo;
+
+        this.teveErro = false;
+        this.teveErroEmTempoDeExecucao = false;
+
+        switch (dialeto) {
+            case 'egua':
+                this.interpretador = new InterpretadorEguaClassico(this, process.cwd());
+                this.lexador = new LexerEguaClassico(this);
+                this.avaliadorSintatico = new ParserEguaClassico(this);
+                this.resolvedor = new ResolverEguaClassico(this, this.interpretador);
+                console.log('Usando dialeto: Égua');
+                break;
+            case 'eguac':
+                this.interpretador = new Interpretador(this, process.cwd());
+                this.lexador = new Lexer(this);
+                this.avaliadorSintatico = new Parser(this);
+                this.resolvedor = new Resolver(this, this.interpretador);
+                console.log('Usando dialeto: ÉguaC');
+                break;
+            case 'eguap':
+                this.interpretador = new Interpretador(this, process.cwd());
+                this.lexador = new Lexer(this);
+                this.avaliadorSintatico = new Parser(this);
+                this.resolvedor = new Resolver(this, this.interpretador);
+                console.log('Usando dialeto: ÉguaP');
+                break;
+            default:
+                this.interpretador = new Interpretador(this, process.cwd());
+                this.lexador = new Lexer(this);
+                this.avaliadorSintatico = new Parser(this);
+                this.resolvedor = new Resolver(this, this.interpretador);
+                console.log('Usando dialeto: padrão');
+                break;
+        }
+    }
+
+    versao() {
+        return JSON.parse(fs.readFileSync('./package.json', { encoding: 'utf8' })).version || ''
+    }
+
+    iniciarDelegua() {
+        const interpretador = new Interpretador(this, process.cwd());
+        console.log(`Console da Linguagem Delégua v${this.versao()}`);
+        const leiaLinha = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: "\ndelegua> "
+        });
+
+        leiaLinha.prompt();
+
+        leiaLinha.on("line", linha => {
+            this.teveErro = false;
+            this.teveErroEmTempoDeExecucao = false;
+
+            this.run(linha, interpretador);
+            leiaLinha.prompt();
+        });
+    }
+
+    carregarArquivo(nomeArquivo: any) {
+        this.nomeArquivo = caminho.basename(nomeArquivo);
+        const interpretador = new Interpretador(this, process.cwd());
+
+        const dadosDoArquivo = fs.readFileSync(nomeArquivo).toString();
+        this.run(dadosDoArquivo, interpretador);
+
+        if (this.teveErro) process.exit(65);
+        if (this.teveErroEmTempoDeExecucao) process.exit(70);
+    }
+
+    run(codigo: any, interpretador: any) {
+        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: any, caractere: any, mensagem: any) {
+        this.reportar(linha, ` no '${caractere}'`, mensagem);
+    }
+
+    erroEmTempoDeExecucao(erro: any) {
+        if (erro & erro.simbolo && 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 if (!(erro instanceof ReturnException)) { // TODO: Ao se livrar de ReturnException, remover isto.
+            console.error(`Erro: ${erro.mensagem}`);
+        }
+        
+        this.teveErroEmTempoDeExecucao = true;
+    }
+};

package/src/estruturas/callable.ts

@@ -0,0 +1,11 @@
+export class Callable {
+    valorAridade: any;
+
+    aridade() {
+        return this.valorAridade;
+    }
+
+    chamar(interpretador?: any, argumentos?: any, simbolo?: any) {
+        throw new Error("Este método não deveria ser chamado.");
+    }
+}

package/src/estruturas/{classe.js → classe.ts}

@@ -1,15 +1,19 @@
-const Callable = require("./callable.js");
-const DeleguaInstancia = require("./instancia.js");
+import { Callable } from "./callable";
+import { DeleguaInstancia } from "./instancia";
 
-module.exports = class DeleguaClasse extends Callable {
-    constructor(nome, superClasse, metodos) {
+export class DeleguaClasse extends Callable {
+    nome: any;
+    superClasse: any;
+    metodos: any;
+
+    constructor(nome?: any, superClasse?: any, metodos?: any) {
         super();
         this.nome = nome;
         this.superClasse = superClasse;
         this.metodos = metodos;
     }
 
-    encontrarMetodo(nome) {
+    encontrarMetodo(nome: any) {
         if (this.metodos.hasOwnProperty(nome)) {
             return this.metodos[nome];
         }
@@ -30,7 +34,7 @@ module.exports = class DeleguaClasse extends Callable {
         return inicializador ? inicializador.aridade() : 0;
     }
 
-    call(interpretador, argumentos) {
+    chamar(interpretador: any, argumentos: any) {
         let instancia = new DeleguaInstancia(this);
 
         let inicializador = this.encontrarMetodo("construtor");
@@ -40,4 +44,4 @@ module.exports = class DeleguaClasse extends Callable {
 
         return instancia;
     }
-};
+}

package/src/estruturas/{funcaoPadrao.js → funcao-padrao.ts}

@@ -1,13 +1,17 @@
-const Callable = require("./callable.js");
+import { Callable } from "./callable";
+
+export class FuncaoPadrao extends Callable {
+    valorAridade: any;
+    funcao: any;
+    simbolo: any;
 
-module.exports = class FuncaoPadrao extends Callable {
     constructor(valorAridade, funcao) {
         super();
         this.valorAridade = valorAridade;
         this.funcao = funcao;
     }
 
-    chamar(interpretador, argumentos, simbolo) {
+    chamar(interpretador: any, argumentos: any, simbolo: any) {
         this.simbolo = simbolo;
         return this.funcao.apply(this, argumentos);
     }
@@ -15,4 +19,4 @@ module.exports = class FuncaoPadrao extends Callable {
     toString() {
         return "<função>";
     }
-};
+}

package/src/estruturas/funcao.ts

@@ -0,0 +1,70 @@
+import { Callable } from "./callable";
+import { Ambiente } from "../ambiente";
+import { ReturnException } from "../excecoes";
+
+export class DeleguaFuncao extends Callable {
+    nome: any;
+    declaracao: any;
+    closure: any;
+    eInicializador: any;
+
+    constructor(nome: any, declaracao: any, closure: any, eInicializador = false) {
+        super();
+        this.nome = nome;
+        this.declaracao = declaracao;
+        this.closure = closure;
+        this.eInicializador = eInicializador;
+    }
+
+    aridade() {
+        return this.declaracao?.parametros?.length || 0;
+    }
+
+    toString() {
+        if (this.nome === null) return "<função>";
+        return `<função ${this.nome}>`;
+    }
+
+    chamar(interpretador: any, argumentos: any) {
+        let ambiente = new Ambiente(this.closure);
+        let parametros = this.declaracao.parametros;
+
+        if (parametros && parametros.length) {
+            for (let i = 0; i < parametros.length; i++) {
+                const param = parametros[i];
+
+                const nome = param["nome"].lexema;
+                let valor = argumentos[i];
+                if (argumentos[i] === null) {
+                    valor = param["padrao"] ? param["padrao"].valor : null;
+                }
+                ambiente.definirVariavel(nome, valor);
+            }
+        }
+
+        try {
+            interpretador.executeBlock(this.declaracao.funcao, ambiente);
+        } catch (erro) {
+            if (erro instanceof ReturnException) {
+                if (this.eInicializador) return this.closure.obterVariavelEm(0, "isto");
+                return erro.valor;
+            } else {
+                throw erro;
+            }
+        }
+
+        if (this.eInicializador) return this.closure.obterVariavelEm(0, "isto");
+        return null;
+    }
+
+    bind(instancia: any) {
+        let ambiente = new Ambiente(this.closure);
+        ambiente.definirVariavel("isto", instancia);
+        return new DeleguaFuncao(
+            this.nome,
+            this.declaracao,
+            ambiente,
+            this.eInicializador
+        );
+    }
+}

package/src/estruturas/index.ts

@@ -0,0 +1,6 @@
+export * from "./callable";
+export * from "./classe";
+export * from "./funcao-padrao";
+export * from "./funcao";
+export * from "./instancia";
+export * from "./modulo";

package/src/estruturas/{instancia.js → instancia.ts}

@@ -1,27 +1,30 @@
-const ErroEmTempoDeExecucao = require("../erro.js").ErroEmTempoDeExecucao;
+import { ErroEmTempoDeExecucao } from "../excecoes";
+
+export class DeleguaInstancia {
+    criarClasse: any;
+    campos: any;
 
-module.exports = class DeleguaInstancia {
     constructor(criarClasse) {
         this.criarClasse = criarClasse;
         this.campos = {};
     }
 
-    get(nome) {
-        if (this.campos.hasOwnProperty(nome.lexeme)) {
-            return this.campos[nome.lexeme];
+    get(nome: any) {
+        if (this.campos.hasOwnProperty(nome.lexema)) {
+            return this.campos[nome.lexema];
         }
 
-        let metodo = this.criarClasse.encontrarMetodo(nome.lexeme);
+        let metodo = this.criarClasse.encontrarMetodo(nome.lexema);
         if (metodo) return metodo.bind(this);
 
         throw new ErroEmTempoDeExecucao(nome, "Método indefinido não recuperado.");
     }
 
-    set(nome, valor) {
-        this.campos[nome.lexeme] = valor;
+    set(nome: any, valor: any) {
+        this.campos[nome.lexema] = valor;
     }
 
     toString() {
         return "<Objeto " + this.criarClasse.nome + ">";
     }
-};
+}

package/src/estruturas/modulo.ts

@@ -0,0 +1,11 @@
+export class DeleguaModulo {
+    nome: string;
+
+    constructor(nome?: string) {
+        if (nome) this.nome = nome;
+    }
+
+    toString() {
+        return this.nome ? `<modulo ${this.nome}>` : "<modulo>";
+    }
+}

package/src/excecoes/break-exception.ts

@@ -0,0 +1 @@
+export class BreakException extends Error { }

package/src/excecoes/continue-exception.ts

@@ -0,0 +1 @@
+export class ContinueException extends Error { }

package/src/excecoes/erro-em-tempo-de-execucao.ts

@@ -0,0 +1,11 @@
+export class ErroEmTempoDeExecucao extends Error {
+  simbolo: any;
+  mensagem: string;
+
+  constructor(simbolo?: any, mensagem?: string) {
+    super(mensagem);
+    this.simbolo = simbolo;
+    this.mensagem = mensagem;
+    Object.setPrototypeOf(this, ErroEmTempoDeExecucao.prototype);
+  }
+}

package/src/excecoes/index.ts

@@ -0,0 +1,4 @@
+export * from "./break-exception";
+export * from "./continue-exception";
+export * from "./erro-em-tempo-de-execucao";
+export * from "./return-exception";

package/src/excecoes/return-exception.ts

@@ -0,0 +1,10 @@
+
+export class ReturnException extends Error {
+  valor: any;
+
+  constructor(valor: any) {
+    super(valor);
+    this.valor = valor;
+    Object.setPrototypeOf(this, ReturnException.prototype);
+  }
+}