@designliquido/delegua 0.1.0 → 0.1.1

package/src/declaracoes/index.ts

@@ -1,243 +0,0 @@
-export class Stmt {
-    aceitar(visitor) { }
-}
-
-export class Expressao extends Stmt {
-    expressao: any;
-
-    constructor(expressao) {
-        super();
-        this.expressao = expressao;
-    }
-
-    aceitar(visitor: any) {
-        return visitor.visitExpressionStmt(this)
-    }
-}
-
-export class Funcao extends Stmt {
-    nome: string;
-    funcao: any;
-
-    constructor(nome: any, funcao: any) {
-        super();
-        this.nome = nome;
-        this.funcao = funcao;
-    }
-
-    aceitar(visitor: any) {
-        return visitor.visitFunctionStmt(this);
-    }
-}
-
-export class Retorna extends Stmt {
-    palavraChave: string;
-    valor: any;
-
-    constructor(palavraChave, valor) {
-        super();
-        this.palavraChave = palavraChave;
-        this.valor = valor;
-    }
-
-    aceitar(visitor) {
-        return visitor.visitReturnStmt(this);
-    }
-}
-
-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: any) {
-        return visitor.visitClassStmt(this);
-    }
-}
-
-export class Block extends Stmt {
-    declaracoes: any;
-
-    constructor(declaracoes) {
-        super();
-        this.declaracoes = declaracoes;
-    }
-
-    aceitar(visitor) {
-        return visitor.visitBlockStmt(this);
-    }
-}
-
-export class Escreva extends Stmt {
-    expressao: any;
-
-    constructor(expressao) {
-        super();
-        this.expressao = expressao;
-    }
-
-    aceitar(visitor) {
-        return visitor.visitPrintStmt(this);
-    }
-}
-
-export class Importar extends Stmt {
-    caminho: string;
-    closeBracket: any;
-
-    constructor(caminho, closeBracket) {
-        super();
-        this.caminho = caminho;
-        this.closeBracket = closeBracket;
-    }
-
-    aceitar(visitor) {
-        return visitor.visitImportStmt(this);
-    }
-}
-
-export class Fazer extends Stmt {
-    doBranch: any;
-    whileCondition: any;
-
-    constructor(doBranch, whileCondition) {
-        super();
-        this.doBranch = doBranch;
-        this.whileCondition = whileCondition;
-    }
-
-    aceitar(visitor) {
-        return visitor.visitDoStmt(this);
-    }
-}
-
-export class Enquanto extends Stmt {
-    condicao: any;
-    corpo: any;
-
-    constructor(condicao, corpo) {
-        super();
-        this.condicao = condicao;
-        this.corpo = corpo;
-    }
-
-    aceitar(visitor) {
-        return visitor.visitWhileStmt(this);
-    }
-}
-
-export class Para extends Stmt {
-    inicializador: any;
-    condicao: any;
-    incrementar: any;
-    corpo: any;
-
-    constructor(inicializador, condicao, incrementar, corpo) {
-        super();
-        this.inicializador = inicializador;
-        this.condicao = condicao;
-        this.incrementar = incrementar;
-        this.corpo = corpo;
-    }
-
-    aceitar(visitor) {
-        return visitor.visitForStmt(this);
-    }
-}
-
-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;
-        this.elseBranch = elseBranch;
-        this.finallyBranch = finallyBranch;
-    }
-
-    aceitar(visitor: any) {
-        return visitor.visitTryStmt(this);
-    }
-}
-
-export class Se extends Stmt {
-    condicao: any;
-    thenBranch: any;
-    elifBranches: any;
-    elseBranch: any;
-
-    constructor(condicao, thenBranch, elifBranches, elseBranch) {
-        super();
-        this.condicao = condicao;
-        this.thenBranch = thenBranch;
-        this.elifBranches = elifBranches;
-        this.elseBranch = elseBranch;
-    }
-
-    aceitar(visitor) {
-        return visitor.visitIfStmt(this);
-    }
-}
-
-export class Escolha extends Stmt {
-    condicao: any;
-    branches: any;
-    defaultBranch: any;
-
-    constructor(condicao, branches, defaultBranch) {
-        super();
-        this.condicao = condicao;
-        this.branches = branches;
-        this.defaultBranch = defaultBranch;
-    }
-
-    aceitar(visitor) {
-        return visitor.visitSwitchStmt(this);
-    }
-}
-
-export class Pausa extends Stmt {
-    constructor() {
-        super();
-    }
-
-    aceitar(visitor) {
-        return visitor.visitBreakStmt(this);
-    }
-}
-
-export class Continua extends Stmt {
-    constructor() {
-        super();
-    }
-
-    aceitar(visitor) {
-        return visitor.visitContinueStmt(this);
-    }
-}
-
-export class Var extends Stmt {
-    nome: any;
-    inicializador: any;
-
-    constructor(nome: any, inicializador: any) {
-        super();
-        this.nome = nome;
-        this.inicializador = inicializador;
-    }
-
-    aceitar(visitor: any) {
-        return visitor.visitVarStmt(this);
-    }
-}

package/src/delegua.ts

@@ -1,156 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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.ts

@@ -1,47 +0,0 @@
-import { Callable } from "./callable";
-import { DeleguaInstancia } from "./instancia";
-
-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: any) {
-        if (this.metodos.hasOwnProperty(nome)) {
-            return this.metodos[nome];
-        }
-
-        if (this.superClasse !== null) {
-            return this.superClasse.encontrarMetodo(nome);
-        }
-
-        return undefined;
-    }
-
-    toString() {
-        return `<classe ${this.nome}>`;
-    }
-
-    aridade() {
-        let inicializador = this.encontrarMetodo("construtor");
-        return inicializador ? inicializador.aridade() : 0;
-    }
-
-    chamar(interpretador: any, argumentos: any) {
-        let instancia = new DeleguaInstancia(this);
-
-        let inicializador = this.encontrarMetodo("construtor");
-        if (inicializador) {
-            inicializador.bind(instancia).call(interpretador, argumentos);
-        }
-
-        return instancia;
-    }
-}

package/src/estruturas/funcao-padrao.ts

@@ -1,22 +0,0 @@
-import { Callable } from "./callable";
-
-export class FuncaoPadrao extends Callable {
-    valorAridade: any;
-    funcao: any;
-    simbolo: any;
-
-    constructor(valorAridade, funcao) {
-        super();
-        this.valorAridade = valorAridade;
-        this.funcao = funcao;
-    }
-
-    chamar(interpretador: any, argumentos: any, simbolo: any) {
-        this.simbolo = simbolo;
-        return this.funcao.apply(this, argumentos);
-    }
-
-    toString() {
-        return "<função>";
-    }
-}

package/src/estruturas/funcao.ts

@@ -1,70 +0,0 @@
-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

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

package/src/estruturas/instancia.ts

@@ -1,30 +0,0 @@
-import { ErroEmTempoDeExecucao } from "../excecoes";
-
-export class DeleguaInstancia {
-    criarClasse: any;
-    campos: any;
-
-    constructor(criarClasse) {
-        this.criarClasse = criarClasse;
-        this.campos = {};
-    }
-
-    get(nome: any) {
-        if (this.campos.hasOwnProperty(nome.lexema)) {
-            return this.campos[nome.lexema];
-        }
-
-        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: any, valor: any) {
-        this.campos[nome.lexema] = valor;
-    }
-
-    toString() {
-        return "<Objeto " + this.criarClasse.nome + ">";
-    }
-}

package/src/estruturas/modulo.ts

@@ -1,11 +0,0 @@
-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

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

package/src/excecoes/continue-exception.ts

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

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

@@ -1,11 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

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

package/src/interfaces/avaliador-sintatico-interface.ts

@@ -1,58 +0,0 @@
-import { SimboloInterface } from "./simbolo-interface";
-
-export interface AvaliadorSintaticoInterface {
-    simbolos: SimboloInterface[];
-    Delegua: any;
-  
-    atual: number;
-    ciclos: number;
-
-    sincronizar(): void;
-    erro(simbolo: any, mensagemDeErro: any): any;
-    consumir(tipo: any, mensagemDeErro: any): any;
-    verificar(tipo: any): boolean;
-    verificarProximo(tipo: any): boolean;
-    peek(): any;
-    voltar(): any;
-    seek(posicao: number): any;
-    estaNoFinal(): boolean;
-    avancar(): any;
-    match(...argumentos: any[]): boolean;
-    primario(): any;
-    finalizarChamada(callee: any): any;
-    chamar(): any;
-    unario(): any;
-    exponent(): any;
-    multiplicar(): any;
-    adicionar(): any;
-    bitFill(): any;
-    bitE(): any;
-    bitOu(): any;
-    comparar(): any;
-    equality(): any;
-    em(): any;
-    e(): any;
-    ou(): any;
-    atribuir(): any;
-    expressao(): any;
-    declaracaoMostrar(): any;
-    expressionStatement(): any;
-    block(): any;
-    declaracaoSe(): any;
-    whileStatement(): any;
-    forStatement(): any;
-    breakStatement(): any;
-    declaracaoContinue(): any;
-    declaracaoRetorna(): any;
-    declaracaoEscolha(): any;
-    importStatement(): any;
-    tryStatement(): any;
-    doStatement(): any;
-    statement(): any;
-    declaracaoDeVariavel(): any;
-    funcao(kind: any): any;
-    corpoDaFuncao(kind: any): any;
-    declaracaoDeClasse(): any;
-    declaracao(): any;
-    analisar(): any;
-}