@designliquido/delegua 0.8.1 → 0.9.0

package/fontes/interpretador/interpretador.d.ts

@@ -1,6 +1,8 @@
+/// <reference types="node" />
+import * as readline from 'readline';
 import { EspacoVariaveis } from '../espaco-variaveis';
 import { InterpretadorInterface, SimboloInterface, VariavelInterface } from '../interfaces';
-import { Bloco, Classe, Continua, Declaracao, Enquanto, Escolha, Escreva, Expressao, Fazer, Funcao, Importar, Leia, Para, Retorna, Se, Tente, Var } from '../declaracoes';
+import { Bloco, Classe, Continua, Declaracao, Enquanto, Escolha, Escreva, Expressao, Fazer, FuncaoDeclaracao, Importar, Leia, Para, Retorna, Se, Tente, Var } from '../declaracoes';
 import { DeleguaFuncao } from '../estruturas';
 import { AcessoIndiceVariavel, Atribuir, Construto, Literal, Super, Variavel } from '../construtos';
 import { ErroInterpretador } from './erro-interpretador';
@@ -18,17 +20,20 @@ export declare class Interpretador implements InterpretadorInterface {
     erros: ErroInterpretador[];
     performance: boolean;
     funcaoDeRetorno: Function;
+    interfaceDeEntrada: readline.Interface;
     resultadoInterpretador: Array<string>;
     declaracoes: Declaracao[];
     pilhaEscoposExecucao: PilhaEscoposExecucaoInterface;
+    interfaceEntradaSaida: any;
     regexInterpolacao: RegExp;
-    constructor(importador: ImportadorInterface, diretorioBase: string, performance: boolean, funcaoDeRetorno: Function);
+    constructor(importador: ImportadorInterface, diretorioBase: string, performance?: boolean, funcaoDeRetorno?: Function);
     /**
      * Execução da leitura de valores da entrada configurada no
      * início da aplicação.
-     * @param expressao
+     * @param expressao Expressão do tipo Leia
+     * @returns Promise com o resultado da leitura.
      */
-    visitarExpressaoLeia(expressao: Leia): void;
+    visitarExpressaoLeia(expressao: Leia): Promise<any>;
     /**
      * Retira a interpolação de um texto.
      * @param {texto} texto O texto
@@ -43,11 +48,11 @@ export declare class Interpretador implements InterpretadorInterface {
      */
     buscarVariaveisInterpolacao(textoOriginal: string): any[];
     visitarExpressaoLiteral(expressao: Literal): any;
-    avaliar(expressao: Construto): any;
-    visitarExpressaoAgrupamento(expressao: any): any;
+    avaliar(expressao: Construto): Promise<any>;
+    visitarExpressaoAgrupamento(expressao: any): Promise<any>;
     eVerdadeiro(objeto: any): boolean;
-    verificarOperandoNumero(operador: any, operando: any): void;
-    visitarExpressaoUnaria(expressao: any): any;
+    verificarOperandoNumero(operador: SimboloInterface, operando: any): void;
+    visitarExpressaoUnaria(expressao: any): Promise<any>;
     eIgual(esquerda: VariavelInterface | any, direita: VariavelInterface | any): boolean;
     /**
      * Verifica se operandos são números, que podem ser tanto variáveis puras do JavaScript
@@ -58,43 +63,43 @@ export declare class Interpretador implements InterpretadorInterface {
      * @returns Se ambos os operandos são números ou não.
      */
     verificarOperandosNumeros(operador: any, direita: VariavelInterface | any, esquerda: VariavelInterface | any): void;
-    visitarExpressaoBinaria(expressao: any): any;
+    visitarExpressaoBinaria(expressao: any): Promise<any>;
     /**
      * Executa uma chamada de função, método ou classe.
      * @param expressao A expressão chamada.
      * @returns O resultado da chamada.
      */
-    visitarExpressaoDeChamada(expressao: any): any;
+    visitarExpressaoDeChamada(expressao: any): Promise<any>;
     /**
      * Execução de uma expressão de atribuição.
      * @param expressao A expressão.
      * @returns O valor atribuído.
      */
-    visitarExpressaoDeAtribuicao(expressao: Atribuir): any;
+    visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<any>;
     procurarVariavel(simbolo: SimboloInterface): any;
     visitarExpressaoDeVariavel(expressao: Variavel): any;
-    visitarDeclaracaoDeExpressao(declaracao: Expressao): any;
-    visitarExpressaoLogica(expressao: any): any;
+    visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any>;
+    visitarExpressaoLogica(expressao: any): Promise<any>;
     /**
      * Executa uma expressão Se, que tem uma condição, pode ter um bloco
      * Senão, e múltiplos blocos Senão-se.
      * @param declaracao A declaração Se.
      * @returns O resultado da avaliação do bloco cuja condição é verdadeira.
      */
-    visitarExpressaoSe(declaracao: Se): any;
-    visitarExpressaoPara(declaracao: Para): any;
-    visitarExpressaoFazer(declaracao: Fazer): any;
-    visitarExpressaoEscolha(declaracao: Escolha): any;
-    visitarExpressaoTente(declaracao: Tente): any;
-    visitarExpressaoEnquanto(declaracao: Enquanto): any;
-    visitarExpressaoImportar(declaracao: Importar): any;
+    visitarExpressaoSe(declaracao: Se): Promise<any>;
+    visitarExpressaoPara(declaracao: Para): Promise<any>;
+    visitarExpressaoFazer(declaracao: Fazer): Promise<any>;
+    visitarExpressaoEscolha(declaracao: Escolha): Promise<any>;
+    visitarExpressaoTente(declaracao: Tente): Promise<any>;
+    visitarExpressaoEnquanto(declaracao: Enquanto): Promise<any>;
+    visitarExpressaoImportar(declaracao: Importar): Promise<any>;
     /**
      * Execução de uma escrita na saída configurada, que pode ser `console` (padrão) ou
      * alguma função para escrever numa página Web.
      * @param declaracao A declaração.
      * @returns Sempre nulo, por convenção de visita.
      */
-    visitarExpressaoEscreva(declaracao: Escreva): any;
+    visitarExpressaoEscreva(declaracao: Escreva): Promise<any>;
     /**
      * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
      * executa as declarações empilhadas.
@@ -104,37 +109,37 @@ export declare class Interpretador implements InterpretadorInterface {
      * @param declaracoes Um vetor de declaracoes a ser executado.
      * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
      */
-    executarBloco(declaracoes: Declaracao[], ambiente?: EspacoVariaveis): any;
-    visitarExpressaoBloco(declaracao: Bloco): any;
+    executarBloco(declaracoes: Declaracao[], ambiente?: EspacoVariaveis): Promise<any>;
+    visitarExpressaoBloco(declaracao: Bloco): Promise<any>;
     /**
      * Executa expressão de definição de variável.
      * @param declaracao A declaração Var
      * @returns Sempre retorna nulo.
      */
-    visitarExpressaoVar(declaracao: Var): any;
+    visitarExpressaoVar(declaracao: Var): Promise<any>;
     visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra;
     visitarExpressaoSustar(declaracao?: any): SustarQuebra;
-    visitarExpressaoRetornar(declaracao: Retorna): RetornoQuebra;
+    visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
     visitarExpressaoDeleguaFuncao(expressao: any): DeleguaFuncao;
-    visitarExpressaoAtribuicaoSobrescrita(expressao: any): void;
-    visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel | any): any;
-    visitarExpressaoDefinir(expressao: any): any;
-    visitarExpressaoFuncao(declaracao: Funcao): void;
+    visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any>;
+    visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel | any): Promise<any>;
+    visitarExpressaoDefinirValor(expressao: any): Promise<any>;
+    visitarExpressaoFuncao(declaracao: FuncaoDeclaracao): void;
     /**
      * Executa uma declaração de classe.
      * @param declaracao A declaração de classe.
      * @returns Sempre retorna nulo, por ser requerido pelo contrato de visita.
      */
-    visitarExpressaoClasse(declaracao: Classe): any;
+    visitarExpressaoClasse(declaracao: Classe): Promise<any>;
     /**
      * Executa um acesso a método, normalmente de um objeto de classe.
      * @param expressao A expressão de acesso.
      * @returns O resultado da execução.
      */
-    visitarExpressaoAcessoMetodo(expressao: any): any;
+    visitarExpressaoAcessoMetodo(expressao: any): Promise<any>;
     visitarExpressaoIsto(expressao: any): any;
-    visitarExpressaoDicionario(expressao: any): {};
-    visitarExpressaoVetor(expressao: any): any[];
+    visitarExpressaoDicionario(expressao: any): Promise<any>;
+    visitarExpressaoVetor(expressao: any): Promise<any>;
     visitarExpressaoSuper(expressao: Super): any;
     paraTexto(objeto: any): any;
     /**
@@ -143,7 +148,7 @@ export declare class Interpretador implements InterpretadorInterface {
      * @param mostrarResultado Se resultado deve ser mostrado ou não. Normalmente usado
      *                         pelo modo LAIR.
      */
-    executar(declaracao: Declaracao, mostrarResultado?: boolean): any;
+    executar(declaracao: Declaracao, mostrarResultado?: boolean): Promise<any>;
     /**
      * Executa o último escopo empilhado no topo na pilha de escopos do interpretador.
      * Esse método pega exceções, mas apenas as devolve.
@@ -154,7 +159,7 @@ export declare class Interpretador implements InterpretadorInterface {
      * @param manterAmbiente Se verdadeiro, ambiente do topo da pilha de escopo é copiado para o ambiente imediatamente abaixo.
      * @returns O resultado da execução do escopo, se houver.
      */
-    executarUltimoEscopo(manterAmbiente?: boolean): any;
+    executarUltimoEscopo(manterAmbiente?: boolean): Promise<any>;
     /**
      * Interpretação sem depurador, com medição de performance.
      * Método que efetivamente inicia o processo de interpretação.
@@ -163,5 +168,5 @@ export declare class Interpretador implements InterpretadorInterface {
      *                       pelo modo REPL (LEIA).
      * @returns Um objeto com o resultado da interpretação.
      */
-    interpretar(declaracoes: Declaracao[], manterAmbiente?: boolean): RetornoInterpretador;
+    interpretar(declaracoes: Declaracao[], manterAmbiente?: boolean): Promise<RetornoInterpretador>;
 }