@designliquido/delegua/interpretador/interpretador-base.d.ts

Linguagem de programação simples e moderna usando português estruturado.

import { Bloco, CabecalhoPrograma, Classe, Comentario, Const, ConstMultiplo, Continua, Declaracao, Enquanto, Escolha, Escreva, EscrevaMesmaLinha, Expressao, Extensao, Falhar, Fazer, FuncaoDeclaracao, Importar, InicioAlgoritmo, InterfaceDeclaracao, Para, ParaCada, Retorna, Se, TendoComo, Tente, TextoDocumentacao, Var, VarMultiplo } from '../declaracoes';
import { Chamavel, DescritorTipoClasse, DeleguaFuncao, DeleguaModulo } from './estruturas';
import { AcessoIndiceVariavel, AcessoIntervaloVariavel, AcessoMetodo, AcessoMetodoOuPropriedade, AcessoPropriedade, Agrupamento, ArgumentoReferenciaFuncao, AtribuicaoPorIndice, Atribuir, Chamada, ComentarioComoConstruto, Construto, DefinirValor, Dicionario, ExpressaoRegular, FimPara, FormatacaoEscrita, FuncaoConstruto, Leia, Literal, Logico, ReferenciaFuncao, Separador, Super, TipoDe, Tupla, TuplaN, Unario, Variavel, Vetor, Isto, Binario } from '../construtos';
import { ErroInterpretadorInterface } from '../interfaces/erros/erro-interpretador-interface';
import { RetornoInterpretadorInterface } from '../interfaces/retornos/retorno-interpretador-interface';
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, ResultadoParcialInterpretadorInterface, 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: ErroInterpretadorInterface[];
    declaracoes: Declaracao[];
    resultadoInterpretador: ResultadoParcialInterpretadorInterface[];
    linhaDeclaracaoAtual: number;
    hashArquivoDeclaracaoAtual: number;
    classeAtualEmExecucao: any;
    expandirPropriedadesDeObjetosEmEspacoMemoria: boolean;
    requerDeclaracaoPropriedades: boolean;
    performance: boolean;
    funcaoDeRetorno: Function;
    funcaoDeRetornoMesmaLinha: Function;
    interfaceDeEntrada: any;
    interfaceEntradaSaida: any;
    emDeclaracaoTente: boolean;
    pilhaEscoposExecucao: PilhaEscoposExecucaoInterface;
    extensoesGlobais: Map<string, Map<string, DeleguaFuncao>>;
    extensoesModulo: Map<number, Map<string, Map<string, DeleguaFuncao>>>;
    microLexador: MicroLexador;
    microAvaliadorSintatico: MicroAvaliadorSintaticoBase;
    regexInterpolacao: RegExp;
    private iteracoesParaCederControle;
    private tiposNumericos;
    lancarErroPorDivisaoPorZero: boolean;
    constructor(diretorioBase: string, performance?: boolean, funcaoDeRetorno?: Function, funcaoDeRetornoMesmaLinha?: Function);
    /**
     * Cede o controle ao loop de eventos do JavaScript.
     * Usado em laços de repetição para evitar bloqueio do loop de eventos
     * em iterações longas ou infinitas.
     */
    protected cederControle(iteracoes: number): Promise<void>;
    visitarDeclaracaoTextoDocumentacao(declaracao: TextoDocumentacao): Promise<any> | void;
    visitarExpressaoSeparador(expressao: Separador): Promise<any> | void;
    visitarExpressaoComentario(expressao: ComentarioComoConstruto): Promise<any> | void;
    /**
     * Usado para chamadas de métodos de primitiva.
     * Sendo uma variável ou constante, a primitiva precisa atualizar a referência
     * para o objeto que está sendo acessado.
     * @param {Construto} objetoAcessado O objeto que está sendo acessado.
     * @returns O nome desse objeto, se ele for uma variável ou constante.
     * @see resolverValor
     */
    protected resolverNomeObjectoAcessado(objetoAcessado: Construto): string;
    resolverValor(objeto: any): any;
    /**
     * Resolve valores recursivamente, incluindo valores aninhados em arrays e dicionários.
     * Remove metadados que não devem ser serializados.
     * @param objeto O objeto a ser resolvido
     * @returns O valor resolvido sem metadados
     */
    protected resolverValorRecursivo(objeto: any): any;
    visitarExpressaoArgumentoReferenciaFuncao(expressao: ArgumentoReferenciaFuncao): Promise<any>;
    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>;
    visitarExpressaoTuplaN(expressao: TuplaN): 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>;
    visitarExpressaoReferenciaFuncao(expressao: ReferenciaFuncao): Promise<any>;
    /**
     * Chama o método `aceitar` de um construto ou declaração, passando o
     * próprio interpretador como parâmetro.
     *
     * Isto é usado para saber qual método do próprio interpretador chamar
     * na sequência.
     * @param expressao A expressão, que pode ser um construto ou declaração.
     * @returns O retorno da execução do método de visita chamado.
     */
    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[]} interpolacoes A lista de interpolações a serem resolvidas.
     * @returns O texto com o valor das variáveis.
     */
    protected retirarInterpolacao(texto: string, interpolacoes: {
        expressaoInterpolacao: string;
        valor: 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>;
    /**
     * Avaliação de agrupamento. Se resultado da avaliação é uma declaração de
     * função (por exemplo, funções anônimas), a declaração é retornada. Este
     * retorno é utilizado, entre outros lugares, por `visitarExpressaoDeChamada`.
     * @param {Agrupamento} expressao O construto de agrupamento.
     * @returns O resultado da avaliação.
     * @see this.visitarExpressaoDeChamada
     */
    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: Binario): 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} metodoPrimitivaChamado O método da primitiva chamado.
     * @returns O resultado da chamada do método da primitiva.
     */
    protected chamarMetodoPrimitiva(expressao: Chamada, metodoPrimitivaChamado: 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): 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>;
    protected logicaContemOuEm(esquerda: any, direita: any, expressao: Logico): 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 Um descritor de informações importantes para o retorno externo.
     */
    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>;
    /**
     * Método base para acesso a intervalo.
     * Por padrão lança erro, pois a maioria dos dialetos (como Delégua padrão)
     * ainda não suporta isso nativamente, apenas Pituguês.
     */
    visitarExpressaoAcessoIntervaloVariavel(expressao: AcessoIntervaloVariavel): Promise<any>;
    visitarExpressaoDefinirValor(expressao: DefinirValor): Promise<any>;
    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): Promise<any>;
    /**
     * 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>;
    /**
     * Registra uma declaração de interface no ambiente de execução.
     * Interfaces são verificadas em tempo de análise; em tempo de execução, apenas registramos
     * o nome para possíveis verificações futuras (ex: `eInstanciaDe`).
     */
    visitarDeclaracaoInterface(_declaracao: InterfaceDeclaracao): Promise<void>;
    /**
     * Procura um método de extensão nos registros de módulo e global,
     * percorrendo os tipos na ordem indicada (específico antes de base).
     */
    encontrarMetodoExtensao(tiposParaVerificar: string[], nomeMetodo: string, hashArquivo: number): DeleguaFuncao | undefined;
    /**
     * Registra os métodos de uma declaração de extensão nos registros
     * de extensão do interpretador.
     */
    visitarDeclaracaoExtensao(declaracao: Extensao): Promise<void>;
    /**
     * 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: Isto): 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 Um descritor de informações importantes para o retorno externo.
     */
    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>;
    /**
     * Formata uma string usando o operador % (similar ao Python).
     * @param formato A string de formato com especificadores (ex: "Olá %s").
     * @param valores Os valores para substituir (pode ser um único valor ou uma tupla/vetor).
     * @param operador O símbolo do operador para mensagens de erro.
     * @returns A string formatada.
     */
    private formatarStringComOperadorPorcentagem;
    paraTexto(objeto: any): string;
    /**
     * Efetivamente executa uma declaração.
     * @param declaracao A declaração a ser executada.
     * @returns O resultado parcial da execução, normalmente usado por
     *          ferramentas externas.
     */
    executar(declaracao: Declaracao): Promise<ResultadoParcialInterpretadorInterface>;
    /**
     * 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.
     */
    executarChamavel(chamavel: Chamavel, argumentos: any[]): Promise<any>;
    interpretar(declaracoes: Declaracao[], manterAmbiente?: boolean): Promise<RetornoInterpretadorInterface>;
}
//# sourceMappingURL=interpretador-base.d.ts.map