@designliquido/delegua

import { Aleatorio, Bloco, CabecalhoPrograma, Classe, Comentario, Const, ConstMultiplo, Continua, Declaracao, Enquanto, Escolha, Escreva, EscrevaMesmaLinha, Expressao, Falhar, Fazer, FuncaoDeclaracao, Importar, InicioAlgoritmo, Para, ParaCada, Retorna, Se, TendoComo, Tente, Var, VarMultiplo } from '../declaracoes'; import { DescritorTipoClasse, DeleguaFuncao, DeleguaModulo } from './estruturas'; import { AcessoIndiceVariavel, AcessoMetodo, AcessoMetodoOuPropriedade, AcessoPropriedade, Agrupamento, ArgumentoReferenciaFuncao, AtribuicaoPorIndice, Atribuir, Chamada, Construto, DefinirValor, Dicionario, ExpressaoRegular, FimPara, FormatacaoEscrita, FuncaoConstruto, Leia, Literal, Logico, ReferenciaFuncao, Super, TipoDe, Tupla, Unario, Variavel, Vetor } from '../construtos'; import { ErroInterpretador } from '../interfaces/erros/erro-interpretador'; import { RetornoInterpretador } from '../interfaces/retornos/retorno-interpretador'; import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../quebras'; import { PilhaEscoposExecucaoInterface } from '../interfaces/pilha-escopos-execucao-interface'; import { MetodoPrimitiva } from './estruturas/metodo-primitiva'; import { ArgumentoInterface } from './argumento-interface'; import { MicroLexador } from '../lexador'; import { MicroAvaliadorSintaticoBase } from '../avaliador-sintatico/micro-avaliador-sintatico-base'; import { EspacoMemoria } from './espaco-memoria'; import { InterpretadorInterface, SimboloInterface, VariavelInterface } from '../interfaces'; /** * O Interpretador visita todos os elementos complexos gerados pelo avaliador sintático (_parser_), * e de fato executa a lógica de programação descrita no código. Este interpretador base é usado * por Delégua e todos os seus dialetos, contendo somente os pontos em comum entre todas as * linguagens. * * O Interpretador Base não contém dependências com o Node.js. É * recomendado para uso em execuções que ocorrem no navegador de internet. */ export declare class InterpretadorBase implements InterpretadorInterface { diretorioBase: string; erros: ErroInterpretador[]; declaracoes: Declaracao[]; resultadoInterpretador: Array<string>; linhaDeclaracaoAtual: number; hashArquivoDeclaracaoAtual: number; expandirPropriedadesDeObjetosEmEspacoMemoria: boolean; requerDeclaracaoPropriedades: boolean; performance: boolean; funcaoDeRetorno: Function; funcaoDeRetornoMesmaLinha: Function; interfaceDeEntrada: any; interfaceEntradaSaida: any; emDeclaracaoTente: boolean; pilhaEscoposExecucao: PilhaEscoposExecucaoInterface; microLexador: MicroLexador; microAvaliadorSintatico: MicroAvaliadorSintaticoBase; regexInterpolacao: RegExp; private tiposNumericos; constructor(diretorioBase: string, performance?: boolean, funcaoDeRetorno?: Function, funcaoDeRetornoMesmaLinha?: Function); protected resolverValor(objeto: any): any; visitarExpressaoArgumentoReferenciaFuncao(expressao: ArgumentoReferenciaFuncao): Promise<any> | void; visitarExpressaoReferenciaFuncao(expressao: ReferenciaFuncao): Promise<any> | void; visitarExpressaoAcessoMetodo(expressao: AcessoMetodo): Promise<any> | void; visitarExpressaoAcessoPropriedade(expressao: AcessoPropriedade): Promise<any> | void; /** * Construtos de comentários não têm utilidade para o Interpretador. * Apenas retornamos `Promise.resolve()` para não termos erros. * @param declaracao A declaração de comentário. */ visitarDeclaracaoComentario(declaracao: Comentario): Promise<any>; visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any>; visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any>; visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any>; visitarExpressaoTupla(expressao: Tupla): Promise<any>; visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any>; visitarExpressaoAcessoElementoMatriz(expressao: any): Promise<any>; protected textoParaRegex(texto: string): RegExp; visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<RegExp>; visitarExpressaoTipoDe(expressao: TipoDe): Promise<string>; visitarExpressaoFalhar(expressao: Falhar): Promise<any>; visitarExpressaoFimPara(declaracao: FimPara): Promise<any>; avaliar(expressao: Construto | Declaracao): Promise<any>; /** * Execução da leitura de valores da entrada configurada no * início da aplicação. * @param expressao Expressão do tipo Leia * @returns Promise com o resultado da leitura. */ visitarExpressaoLeia(expressao: Leia): Promise<any>; /** * Retira a interpolação de um texto. * @param {texto} texto O texto * @param {any[]} variaveis A lista de variaveis interpoladas * @returns O texto com o valor das variaveis. */ protected retirarInterpolacao(texto: string, variaveis: any[]): string; /** * Resolve todas as interpolações em um texto. * @param {texto} textoOriginal O texto original com as variáveis interpoladas. * @returns Uma lista de variáveis interpoladas. */ protected resolverInterpolacoes(textoOriginal: string, linha: number): Promise<any[]>; visitarExpressaoLiteral(expressao: Literal): Promise<any>; visitarExpressaoAgrupamento(expressao: Agrupamento): Promise<any>; eVerdadeiro(objeto: any): boolean; protected verificarOperandoNumero(operador: SimboloInterface, operando: any): void; visitarExpressaoUnaria(expressao: Unario): Promise<any>; /** * Formata uma saída de acordo com o número e espaços e casas decimais solicitados. * @param declaracao A declaração de formatação de escrita. * @returns {string} A saída formatada como texto e os respectivos parâmetros aplicados. */ visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): Promise<string>; /** * Lógica para verificação de valores iguais, para Delégua e alguns dialetos. * @param esquerda Uma variável. * @param direita Outra variável. * @returns Verdadeiro se são iguais. Falso em caso contrário. */ eIgual(esquerda: VariavelInterface | any, direita: VariavelInterface | any): boolean; /** * Verifica se operandos são números, que podem ser tanto variáveis puras do JavaScript * (neste caso, `number`), ou podem ser variáveis de Delégua com inferência (`VariavelInterface`). * @param operador O símbolo do operador. * @param direita O operando direito. * @param esquerda O operando esquerdo. * @returns Se ambos os operandos são números ou não. */ protected verificarOperandosNumeros(operador: SimboloInterface, direita: VariavelInterface | any, esquerda: VariavelInterface | any): void; visitarExpressaoBinaria(expressao: any): Promise<any>; /** * Faz a chamada do método de uma primitiva (por exemplo, número, texto, etc.) com seus * respectivos argumentos. * @param {Chamada} expressao A expressão de chamada. * @param {MetodoPrimitiva} entidadeChamada O método da primitiva chamado. * @returns O resultado da chamada do método da primitiva. */ protected chamarMetodoPrimitiva(expressao: Chamada, entidadeChamada: MetodoPrimitiva): Promise<any>; protected resolverArgumentosChamada(expressao: Chamada): Promise<ArgumentoInterface[]>; /** * Executa uma chamada de função, método ou classe. * @param expressao A expressão chamada. * @returns O resultado da chamada. */ visitarExpressaoDeChamada(expressao: Chamada | 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): Promise<any>; protected procurarVariavel(simbolo: SimboloInterface): any; visitarExpressaoDeVariavel(expressao: Variavel): any; visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any>; visitarExpressaoLogica(expressao: Logico): Promise<any>; visitarDeclaracaoPara(declaracao: Para): Promise<any>; visitarDeclaracaoParaCada(declaracao: ParaCada): 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. */ visitarDeclaracaoSe(declaracao: Se): Promise<any>; visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<any>; visitarDeclaracaoEscolha(declaracao: Escolha): Promise<any>; visitarDeclaracaoFazer(declaracao: Fazer): Promise<any>; /** * Interpretação de uma declaração `tente`. * @param declaracao O objeto da declaração. */ visitarDeclaracaoTente(declaracao: Tente): Promise<any>; visitarDeclaracaoImportar(declaracao: Importar): Promise<DeleguaModulo>; protected avaliarArgumentosEscreva(argumentos: Construto[]): Promise<string>; /** * Execução de uma escrita na saída padrão, sem quebras de linha. * Implementada para alguns dialetos, como VisuAlg. * @param declaracao A declaração. * @returns Sempre nulo, por convenção de visita. */ visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): 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. */ visitarDeclaracaoEscreva(declaracao: Escreva): Promise<any>; /** * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e * executa as declarações empilhadas. * Se o retorno do último bloco foi uma exceção (normalmente um erro em tempo de execução), * atira a exceção daqui. * Isso é usado, por exemplo, em blocos tente ... pegue ... finalmente. * @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?: EspacoMemoria): Promise<any>; visitarExpressaoBloco(declaracao: Bloco): Promise<any>; avaliacaoDeclaracaoVarOuConst(declaracao: Const | ConstMultiplo | Var | VarMultiplo): Promise<any>; /** * Executa expressão de definição de constante. * @param declaracao A declaração `Const`. * @returns Sempre retorna nulo. */ visitarDeclaracaoConst(declaracao: Const): Promise<any>; /** * Executa expressão de definição de múltiplas constantes. * @param declaracao A declaração `ConstMultiplo`. * @returns Sempre retorna nulo. */ visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any>; visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra; visitarExpressaoSustar(declaracao?: any): SustarQuebra; visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>; visitarExpressaoFuncaoConstruto(funcaoConstruto: FuncaoConstruto): Promise<DeleguaFuncao>; visitarExpressaoAtribuicaoPorIndice(expressao: AtribuicaoPorIndice): Promise<any>; visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel): Promise<any>; visitarExpressaoDefinirValor(expressao: DefinirValor): Promise<any>; visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): void; /** * Executa uma declaração de classe. * Uma variável do tipo `DeleguaClasse` é adicionada à pilha de escopos de execução. * @param declaracao A declaração de classe. * @returns Sempre retorna nulo, por ser requerido pelo contrato de visita. */ visitarDeclaracaoClasse(declaracao: Classe): Promise<DescritorTipoClasse>; /** * Executa um acesso a método, normalmente de um objeto de classe. * @param {AcessoMetodoOuPropriedade} expressao A expressão de acesso. * @returns O resultado da execução. */ visitarExpressaoAcessoMetodoOuPropriedade(expressao: AcessoMetodoOuPropriedade): Promise<any>; visitarExpressaoIsto(expressao: any): any; visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any>; visitarExpressaoDicionario(expressao: Dicionario): Promise<any>; visitarExpressaoVetor(expressao: Vetor): Promise<any>; visitarExpressaoSuper(expressao: Super): any; /** * Executa expressão de definição de variável. * @param declaracao A declaração Var * @returns Sempre retorna nulo. */ visitarDeclaracaoVar(declaracao: Var): Promise<any>; /** * Executa expressão de definição de múltiplas variáveis. * @param declaracao A declaração `VarMultiplo`. * @returns Sempre retorna nulo. */ visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any>; paraTexto(objeto: any): string; /** * Efetivamente executa uma declaração. * @param declaracao A declaração a ser executada. * @param mostrarResultado Se resultado deve ser mostrado ou não. Normalmente usado * pelo modo LAIR. */ executar(declaracao: Declaracao): 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<any>; /** * Interpretação sem depurador, com medição de performance. * 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<RetornoInterpretador>; } //# sourceMappingURL=interpretador-base.d.ts.map