@designliquido/delegua/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.d.ts

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

import { AcessoMetodo, AcessoPropriedade, Agrupamento, ArgumentoReferenciaFuncao, Atribuir, Construto, ExpressaoRegular, FimPara, FormatacaoEscrita, Leia, Literal, ReferenciaFuncao, Super, TipoDe, Tupla, Variavel } from '../../../construtos';
import { Aleatorio, Bloco, CabecalhoPrograma, Classe, Comentario, Const, ConstMultiplo, Continua, Declaracao, Enquanto, Escolha, Escreva, EscrevaMesmaLinha, Expressao, Fazer, FuncaoDeclaracao, Importar, Para, ParaCada, Retorna, Se, Sustar, TendoComo, Tente, Var, VarMultiplo } from '../../../declaracoes';
import { EspacoMemoria } from '../../espaco-memoria';
import { InterpretadorInterface, SimboloInterface, VariavelInterface } from '../../../interfaces';
import { ErroInterpretador } from '../../../interfaces/erros/erro-interpretador';
import { PilhaEscoposExecucaoInterface } from '../../../interfaces/pilha-escopos-execucao-interface';
import { RetornoInterpretador } from '../../../interfaces/retornos';
import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../../../quebras';
import { InicioAlgoritmo } from '../../../declaracoes/inicio-algoritmo';
export declare class InterpretadorPortugolIpt implements InterpretadorInterface {
    diretorioBase: any;
    funcaoDeRetorno: Function;
    funcaoDeRetornoMesmaLinha: Function;
    pilhaEscoposExecucao: PilhaEscoposExecucaoInterface;
    interfaceEntradaSaida: any;
    declaracoes: Declaracao[];
    erros: ErroInterpretador[];
    resultadoInterpretador: Array<string>;
    constructor(diretorioBase: string, 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;
    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>;
    visitarExpressaoLiteral(expressao: Literal): Promise<any>;
    avaliar(expressao: Construto | Declaracao): Promise<any>;
    visitarExpressaoAgrupamento(expressao: Agrupamento): Promise<any>;
    visitarExpressaoUnaria(expressao: any): never;
    /**
     * 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;
    protected eIgual(esquerda: VariavelInterface | any, direita: VariavelInterface | any): boolean;
    visitarExpressaoBinaria(expressao: any): Promise<any>;
    visitarExpressaoDeChamada(expressao: any): never;
    visitarExpressaoDeAtribuicao(expressao: Atribuir): never;
    protected procurarVariavel(simbolo: SimboloInterface): any;
    visitarExpressaoDeVariavel(expressao: Variavel): any;
    visitarDeclaracaoDeExpressao(declaracao: Expressao): never;
    /**
     * 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>;
    visitarExpressaoLogica(expressao: any): never;
    eVerdadeiro(objeto: any): boolean;
    /**
     * 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>;
    visitarDeclaracaoPara(declaracao: Para): Promise<never>;
    visitarExpressaoFimPara(declaracao: FimPara): never;
    visitarDeclaracaoFazer(declaracao: Fazer): never;
    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): Promise<string>;
    visitarDeclaracaoEscolha(declaracao: Escolha): never;
    visitarDeclaracaoTente(declaracao: Tente): never;
    visitarDeclaracaoEnquanto(declaracao: Enquanto): never;
    visitarDeclaracaoImportar(declaracao: Importar): never;
    protected avaliarArgumentosEscreva(argumentos: Construto[]): Promise<string>;
    /**
     * 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>;
    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): Promise<any>;
    executarBloco(declaracoes: Declaracao[], ambiente?: EspacoMemoria): Promise<any>;
    visitarExpressaoBloco(declaracao: Bloco): Promise<any>;
    protected avaliacaoDeclaracaoVar(declaracao: Var): 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<any>;
    visitarDeclaracaoConst(declaracao: Const): Promise<any>;
    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any>;
    visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra;
    visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra;
    visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
    visitarExpressaoFuncaoConstruto(expressao: any): never;
    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any>;
    visitarExpressaoAcessoIndiceVariavel(expressao: any): never;
    visitarExpressaoDefinirValor(expressao: any): never;
    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): void;
    visitarDeclaracaoClasse(declaracao: Classe): never;
    visitarExpressaoAcessoMetodoOuPropriedade(expressao: any): never;
    visitarExpressaoIsto(expressao: any): never;
    visitarExpressaoDicionario(expressao: any): never;
    visitarExpressaoVetor(expressao: any): never;
    visitarExpressaoSuper(expressao: Super): never;
    paraTexto(objeto: any): any;
    /**
     * 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, mostrarResultado?: boolean): Promise<any>;
    visitarDeclaracaoAleatorio(declaracao: Aleatorio): 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>;
    interpretar(declaracoes: Declaracao[], manterAmbiente?: boolean): Promise<RetornoInterpretador>;
}
//# sourceMappingURL=interpretador-portugol-ipt.d.ts.map