@designliquido/delegua

import { AcessoIndiceVariavel, AcessoMetodo, AcessoMetodoOuPropriedade, AcessoPropriedade, Construto, AtribuicaoPorIndice, Atribuir, Chamada, ComentarioComoConstruto, DefinirValor, Dicionario, EnquantoComoConstruto, FazerComoConstruto, ListaCompreensao, ParaCadaComoConstruto, ParaComoConstruto, Separador, TipoDe, Unario, Vetor, ImportarComoConstruto, Elvis, SeTernario, TuplaN, AjudaComoConstruto } from '../construtos'; import { ReferenciaMontao } from './estruturas'; import { ResultadoParcialInterpretadorInterface, RetornoInterpretadorInterface, VisitanteDeleguaInterface } from '../interfaces'; import { InterpretadorBase } from './interpretador-base'; import { Ajuda, Const, ConstMultiplo, Declaracao, Enquanto, Fazer, FuncaoDeclaracao, InterfaceDeclaracao, Para, ParaCada, Retorna, TendoComo, Var, VarMultiplo } from '../declaracoes'; import { RetornoQuebra } from '../quebras'; import { Montao } from './montao'; import { EnquantoInterface, FazerInterface, ParaCadaInterface, ParaInterface } from '../interfaces/delegua'; /** * O interpretador de Delégua, usado também por Pituguês usando herança. * @see InterpretadorPitugues */ export declare class Interpretador extends InterpretadorBase implements VisitanteDeleguaInterface { montao: Montao; acumularRetornos: boolean; constructor(diretorioBase: string, performance?: boolean, funcaoDeRetorno?: Function, funcaoDeRetornoMesmaLinha?: Function); /** * Cada dialeto que deriva deste interpretador conhece este ponto de inicialização. * A partir daqui, cada dialeto pode carregar as bibliotecas globais específicas do seu dialeto. */ protected pontoInicializacaoBibliotecasGlobais(): void; protected avaliarArgumentosEscreva(argumentos: Construto[]): Promise<string>; protected resolverReferenciaMontao(referenciaMontao: ReferenciaMontao): any; resolverValor(objeto: any, referencia?: boolean): any; private serializarSemEspacos; paraTexto(objeto: any): string; avaliacaoDeclaracaoVarOuConst(declaracao: Const | ConstMultiplo | Var | VarMultiplo): Promise<any>; /** * Declaração de ajuda. * Neste interpretador básico, a ajuda apenas retorna texto sobre um determinado * tópico, ou ainda sobre a ajuda em si. * Outros ambientes implementam mecanismos mais sofisticados, como o modo de ajuda. * @param declaracao A declaração de ajuda. */ visitarDeclaracaoInterface(_declaracao: InterfaceDeclaracao): Promise<any>; visitarDeclaracaoAjuda(declaracao: Ajuda): Promise<any>; visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): Promise<any>; protected logicaComumExecucaoEnquanto(enquanto: EnquantoInterface, acumularRetornos: boolean): Promise<ResultadoParcialInterpretadorInterface | { valorRetornado: any[]; tipo: string; }>; visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<any>; protected logicaComumExecucaoFazer(fazer: FazerInterface, acumularRetornos: boolean): Promise<{ valorRetornado: any[]; tipo: string; }>; visitarDeclaracaoFazer(declaracao: Fazer): Promise<any>; protected logicaComumExecucaoPara(para: ParaInterface, acumularRetornos: boolean): Promise<any>; visitarDeclaracaoPara(declaracao: Para): Promise<any>; protected logicaComumExecucaoParaCada(paraCada: ParaCadaInterface, acumularRetornos: boolean): Promise<any>; visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any>; visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any>; visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel): Promise<any>; visitarExpressaoAcessoMetodo(expressao: AcessoMetodo): Promise<any>; /** * Casos que ocorrem aqui: * * - Quando o método ou propriedade é ou 'qualquer', ou vetor * de 'qualquer' ('qualquer[]'), e uma primitiva é usada. * - Quando o objeto é uma classe definida em código. * @param {AcessoMetodoOuPropriedade} expressao A expressão de acesso a método ou propriedade. * @returns A primitiva encontrada. */ visitarExpressaoAcessoMetodoOuPropriedade(expressao: AcessoMetodoOuPropriedade): Promise<any>; visitarExpressaoAcessoPropriedade(expressao: AcessoPropriedade): Promise<any>; visitarExpressaoAjuda(expressao: AjudaComoConstruto): Promise<any>; visitarExpressaoAtribuicaoPorIndice(expressao: AtribuicaoPorIndice): Promise<any>; /** * Em Delégua e Pituguês, comentários não são importantes para a interpretação. * @param expressao Uma `Promise` sempre resolvida. */ visitarExpressaoComentario(expressao: ComentarioComoConstruto): Promise<any>; /** * Execução de uma expressão de atribuição. * @param expressao A expressão. * @returns O valor atribuído. */ visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<any>; visitarExpressaoDefinirValor(expressao: DefinirValor): Promise<any>; /** * Instâncias de classes em Delégua são passadas por referência, portanto, são * armazenadas no montão. */ visitarExpressaoDeChamada(expressao: Chamada): Promise<any>; /** * Dicionários em Delégua são passados por referência, portanto, são * armazenados no montão. */ visitarExpressaoDicionario(expressao: Dicionario): Promise<any>; visitarExpressaoElvis(expressao: Elvis): Promise<any>; visitarExpressaoEnquanto(expressao: EnquantoComoConstruto): Promise<any> | void; visitarExpressaoFazer(expressao: FazerComoConstruto): Promise<any> | void; visitarExpressaoImportar(expressao: ImportarComoConstruto): Promise<any> | void; visitarExpressaoListaCompreensao(listaCompreensao: ListaCompreensao): Promise<any>; visitarExpressaoPara(expressao: ParaComoConstruto): Promise<any> | void; visitarExpressaoParaCada(expressao: ParaCadaComoConstruto): Promise<any>; visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>; /** * Para Delégua e Pituguês, o separador é apenas um elemento de sintaxe. * Não há qualquer avaliação a ser feita. * @param expressao */ visitarExpressaoSeparador(expressao: Separador): Promise<any>; visitarExpressaoSeTernario(expressao: SeTernario): Promise<any>; visitarExpressaoTipoDe(expressao: TipoDe): Promise<string>; visitarExpressaoUnaria(expressao: Unario): Promise<any>; visitarExpressaoVetor(expressao: Vetor): 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. * * O tratamento das exceções é feito de acordo com o bloco chamador. * Por exemplo, em `tente ... pegue ... finalmente`, a exceção é capturada e tratada. * Em outros blocos, pode ser desejável ter o erro em tela. * @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): Promise<ResultadoParcialInterpretadorInterface>; visitarExpressaoTuplaN(expressao: TuplaN): Promise<any>; /** * Método que efetivamente inicia o processo de interpretação. * @param declaracoes Um vetor de declarações gerado pelo Avaliador Sintático. * @param manterAmbiente Se ambiente de execução (variáveis, classes, etc.) deve ser mantido. Normalmente usado * pelo modo REPL (LAIR). * @returns Um objeto com o resultado da interpretação. */ interpretar(declaracoes: Declaracao[], manterAmbiente?: boolean): Promise<RetornoInterpretadorInterface>; } //# sourceMappingURL=interpretador.d.ts.map