@designliquido/delegua/interpretador/dialetos/egua-classico/interpretador-egua-classico.d.ts

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

import { EspacoMemoria } from '../../espaco-memoria';
import { DeleguaFuncao } from '../../estruturas/delegua-funcao';
import { AcessoIndiceVariavel, AcessoMetodo, AcessoPropriedade, ArgumentoReferenciaFuncao, Atribuir, Construto, ExpressaoRegular, FimPara, FormatacaoEscrita, Isto, Leia, Literal, ReferenciaFuncao, Super, TipoDe, Tupla, Variavel } from '../../../construtos';
import { Aleatorio, CabecalhoPrograma, Classe, Comentario, Const, ConstMultiplo, Declaracao, Enquanto, Escolha, Escreva, EscrevaMesmaLinha, Expressao, Fazer, FuncaoDeclaracao, Importar, Para, ParaCada, Se, TendoComo, Tente, Var, VarMultiplo } from '../../../declaracoes';
import { InterpretadorInterface, ResolvedorInterface, SimboloInterface, VariavelInterface } from '../../../interfaces';
import { ErroInterpretador } from '../../../interfaces/erros/erro-interpretador';
import { RetornoInterpretador } from '../../../interfaces/retornos/retorno-interpretador';
import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../../../quebras';
import { PilhaEscoposExecucao } from '../../pilha-escopos-execucao';
import { InicioAlgoritmo } from '../../../declaracoes/inicio-algoritmo';
/**
 * O Interpretador visita todos os elementos complexos gerados pelo analisador sintático (_Parser_)
 * e de fato executa a lógica de programação descrita no código.
 */
export declare class InterpretadorEguaClassico implements InterpretadorInterface {
    resolvedor: ResolvedorInterface;
    requerDeclaracaoPropriedades: boolean;
    diretorioBase: any;
    funcaoDeRetorno: Function;
    locais: Map<Construto, number>;
    erros: ErroInterpretador[];
    pilhaEscoposExecucao: PilhaEscoposExecucao;
    interfaceEntradaSaida: any;
    constructor(diretorioBase: string);
    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;
    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>;
    visitarExpressaoAcessoElementoMatriz(expressao: any): never;
    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any>;
    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any>;
    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any>;
    visitarExpressaoFalhar(expressao: any): Promise<any>;
    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any>;
    visitarDeclaracaoConst(declaracao: Const): Promise<any>;
    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any>;
    visitarExpressaoFimPara(declaracao: FimPara): never;
    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): never;
    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): never;
    visitarExpressaoLeia(expressao: Leia): Promise<any>;
    visitarExpressaoLiteral(expressao: Literal): any;
    avaliar(expressao: Construto | Declaracao): VariavelInterface | any;
    visitarExpressaoAgrupamento(expressao: any): any;
    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any>;
    eVerdadeiro(objeto: any): boolean;
    verificarOperandoNumero(operador: SimboloInterface, operando: any): void;
    visitarExpressaoUnaria(expr: any): Promise<number | boolean>;
    eIgual(esquerda: VariavelInterface | any, direita: VariavelInterface | any): boolean;
    verificarOperandosNumeros(operador: SimboloInterface, direita: VariavelInterface | any, esquerda: VariavelInterface | any): void;
    visitarExpressaoBinaria(expressao: any): Promise<any>;
    visitarExpressaoDeChamada(expressao: any): Promise<any>;
    visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<any>;
    procurarVariavel(simbolo: SimboloInterface, expressao: any): VariavelInterface;
    visitarExpressaoDeVariavel(expressao: Variavel): Promise<VariavelInterface>;
    visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any>;
    visitarExpressaoLogica(expressao: any): Promise<any>;
    visitarDeclaracaoSe(declaracao: Se): Promise<any>;
    visitarDeclaracaoPara(declaracao: Para): Promise<any>;
    visitarDeclaracaoFazer(declaracao: Fazer): Promise<any>;
    visitarDeclaracaoEscolha(declaracao: Escolha): Promise<void>;
    visitarDeclaracaoTente(declaracao: Tente): Promise<any>;
    visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<any>;
    visitarDeclaracaoImportar(declaracao: Importar): Promise<void>;
    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: any): Promise<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>;
    visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<void>;
    visitarExpressaoContinua(declaracao?: any): ContinuarQuebra;
    visitarExpressaoSustar(declaracao?: any): SustarQuebra;
    visitarExpressaoRetornar(declaracao: any): Promise<RetornoQuebra>;
    visitarExpressaoFuncaoConstruto(expressao: any): Promise<DeleguaFuncao>;
    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<void>;
    visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel | any): Promise<any>;
    visitarExpressaoDefinirValor(expressao: any): Promise<any>;
    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): void;
    visitarDeclaracaoClasse(declaracao: Classe): Promise<any>;
    visitarExpressaoAcessoMetodoOuPropriedade(expressao: any): Promise<any>;
    visitarExpressaoIsto(expressao: Isto): Promise<any>;
    visitarExpressaoDicionario(expressao: any): Promise<{}>;
    visitarExpressaoVetor(expressao: any): Promise<any[]>;
    visitarExpressaoSuper(expressao: Super): any;
    paraTexto(objeto: any): any;
    executar(declaracao: Declaracao, mostrarResultado?: boolean): Promise<any>;
    /**
     * Executa o último escopo empilhado no topo na pilha de escopos do Interpretador.
     * Originalmente, Égua não trabalha com uma pilha de escopos.
     *
     * 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.
     *
     * Essa implementação é derivada do Interpretador de Delégua, mas simulando todos os
     * comportamos do interpretador Égua original.
     * Interpretador Égua: https://github.com/eguatech/egua/blob/master/src/interpreter.js
     * @returns O resultado da execução do escopo, se houver.
     */
    executarUltimoEscopo(): Promise<any>;
    interpretar(declaracoes: Declaracao[]): Promise<RetornoInterpretador>;
    finalizacao(): void;
}
//# sourceMappingURL=interpretador-egua-classico.d.ts.map