import { Binario, Chamada, Construto } from '../../construtos';
import { Declaracao, Enquanto, Escreva, Para, Retorna, Tente } from '../../declaracoes';
import { InterpretadorComDepuracaoInterface } from '../../interfaces';
import { RetornoQuebra } from '../../quebras';
import { TipoEscopoExecucao } from '../../interfaces/escopo-execucao';
import { EspacoMemoria } from '../espaco-memoria';
/**
 * Quando um construto ou declaração possui id, significa que o interpretador
 * deve resolver a avaliação e guardar seu valor até o final do escopo.
 * Isso serve para quando a linguagem está em modo de depuração, e o contexto
 * da execução deixa de existir com um ponto de parada, por exemplo.
 * @param expressao A expressão a ser avaliada.
 * @returns O resultado da avaliação.
 */
export declare function avaliar(interpretador: InterpretadorComDepuracaoInterface, expressao: Construto | Declaracao): Promise<any>;
export declare function visitarExpressaoReferenciaFuncao(interpretador: InterpretadorComDepuracaoInterface, visitarExpressaoReferenciaFuncaoAncestral: (expressao: any) => Promise<any>, expressao: any): Promise<any>;
export declare function visitarExpressaoArgumentoReferenciaFuncao(interpretador: InterpretadorComDepuracaoInterface, visitarExpressaoArgumentoReferenciaFuncaoAncestral: (expressao: any) => Promise<any>, expressao: any): Promise<any>;
export declare function visitarExpressaoDeChamada(interpretador: InterpretadorComDepuracaoInterface, visitarExpressaoDeChamadaAncestral: (expressao: Chamada) => Promise<any>, expressao: Chamada): Promise<any>;
export declare function visitarDeclaracaoEnquanto(interpretador: InterpretadorComDepuracaoInterface, declaracao: Enquanto): 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.
 * Se ponto de parada foi ativado durante a avaliação de argumentos, não escreve.
 * @param declaracao A declaração.
 * @returns Sempre nulo, por convenção de visita.
 */
export declare function visitarDeclaracaoEscreva(interpretador: InterpretadorComDepuracaoInterface, declaracao: Escreva): Promise<any>;
export declare function visitarDeclaracaoPara(interpretador: InterpretadorComDepuracaoInterface, declaracao: Para): Promise<any>;
/**
 * Implementação de try-catch-finally para modo de depuração.
 * Garante que o bloco finally só é executado após o bloco try ser completado.
 * Em modo de passo, detecta quando um novo escopo foi criado e está incompleto,
 * evitando que o finally seja empilhado prematuramente.
 * @param interpretador O interpretador com depuração.
 * @param declaracao A declaração tente-pegue-finalmente.
 * @returns O valor retornado pela execução.
 */
export declare function visitarDeclaracaoTente(interpretador: InterpretadorComDepuracaoInterface, declaracao: Tente): Promise<any>;
/**
 * Ao executar um retorno, manter o valor retornado no Interpretador para
 * uso por linhas que foram executadas com o comando `próximo` do depurador.
 * @param declaracao Uma declaracao Retorna
 * @returns O resultado da execução da visita.
 */
export declare function visitarExpressaoRetornar(interpretador: InterpretadorComDepuracaoInterface, visitarExpressaoRetornarAncestral: (declaracao: Retorna) => Promise<any>, declaracao: Retorna): Promise<RetornoQuebra>;
/**
 * Sobrescreve a visita de expressão binária para permitir step-into em cada lado da expressão.
 * Quando em modo de depuração com step-into, avalia o lado esquerdo primeiro e pausa.
 * Na próxima execução, avalia o lado direito e completa a operação.
 * @param interpretador O interpretador com depuração.
 * @param visitarExpressaoBinariaAncestral Método ancestral para executar a lógica da operação.
 * @param expressao A expressão binária.
 * @returns O resultado da operação binária.
 */
export declare function visitarExpressaoBinaria(interpretador: InterpretadorComDepuracaoInterface, expressao: Binario): Promise<any>;
/**
 * Se bloco de execução já foi instanciado antes (por exemplo, quando há um ponto de parada e a
 * execução do código é retomada pelo depurador), retoma a execução do bloco do ponto em que havia parado.
 * Se bloco de execução ainda não foi instanciado, empilha declarações na pilha de escopos de execução,
 * cria um novo espacoMemoria e executa as declarações empilhadas.
 * Se depurador comandou uma instrução 'adentrar-escopo', execução do bloco não ocorre, mas
 * ponteiros de escopo e execução são atualizados.
 * @param declaracoes Um vetor de declaracoes a ser executado.
 * @param espacoMemoria O espacoMemoria de execução quando houver, como parâmetros, argumentos, etc.
 */
export declare function executarBloco(interpretador: InterpretadorComDepuracaoInterface, declaracoes: Declaracao[], espacoMemoria?: EspacoMemoria): Promise<any>;
/**
 * Continua a interpretação parcial do último ponto em que parou.
 * Pode ser tanto o começo da execução inteira, ou pós comando do depurador
 * quando há um ponto de parada.
 * @param manterEspacoMemoria Se verdadeiro, junta elementos do último escopo com o escopo
 *                       imediatamente abaixo.
 * @param naoVerificarPrimeiraExecucao Booleano que pede ao Interpretador para não
 *                                     verificar o ponto de parada na primeira execução.
 *                                     Normalmente usado pelo Servidor de Depuração para continuar uma linha.
 * @returns Um objeto de retorno, com erros encontrados se houverem.
 */
export declare function executarUltimoEscopoComandoContinuar(interpretador: InterpretadorComDepuracaoInterface, manterEspacoMemoria?: boolean, naoVerificarPrimeiraExecucao?: boolean): Promise<any>;
/**
 * Continua a interpretação, conforme comando do depurador.
 * Quando um ponto de parada é ativado, a pilha de execução do TypeScript é perdida.
 * Esse método cria uma nova pilha de execução do lado do JS, começando do último elemento executado do
 * primeiro escopo, subindo até o último elemento executado do último escopo.
 * Se entre escopos houver ponto de parada ativo, a execução é suspensa até o próximo comando
 * do desenvolvedor.
 * @see executarUltimoEscopo
 */
export declare function instrucaoContinuarInterpretacao(interpretador: InterpretadorComDepuracaoInterface, escopo?: number): Promise<any>;
/**
 * Interpreta apenas uma instrução a partir do ponto de parada ativo, conforme comando do depurador.
 * Esse método cria uma nova pilha de execução do lado do JS, começando do último elemento executado do
 * primeiro escopo, subindo até o último elemento executado do último escopo.
 * @param escopo Indica o escopo a ser visitado. Usado para construir uma pilha de chamadas do lado JS.
 */
export declare function instrucaoPasso(interpretador: InterpretadorComDepuracaoInterface, escopo?: number): Promise<any>;
export declare function abrirNovoBlocoEscopo(interpretador: InterpretadorComDepuracaoInterface, declaracoes: Declaracao[], espacoMemoria?: EspacoMemoria, tipoEscopo?: TipoEscopoExecucao): void;
/**
 * No interpretador com depuração, este método é dividido em dois outros métodos privados:
 * - `executarUmPassoNoEscopo`, que executa apenas uma instrução e nada mais;
 * - `executarUltimoEscopoComandoContinuar`, que é a execução trivial de um escopo inteiro,
 *      ou com todas as instruções, ou até encontrar um ponto de parada.
 * @param manterespacoMemoria Se verdadeiro, junta elementos do último escopo com o escopo
 *                       imediatamente abaixo.
 * @param naoVerificarPrimeiraExecucao Booleano que pede ao Interpretador para não
 *                                     verificar o ponto de parada na primeira execução.
 *                                     Normalmente usado pelo Servidor de Depuração para continuar uma linha.
 * @returns O retorno da execução.
 */
export declare function executarUltimoEscopo(interpretador: InterpretadorComDepuracaoInterface, manterespacoMemoria?: boolean, naoVerificarPrimeiraExecucao?: boolean): Promise<any>;
/**
 * Obtém o valor de uma variável por nome.
 * Em versões anteriores, o mecanismo de avaliação fazia toda a avaliação tradicional,
 * passando por Lexador, Avaliador Sintático e Interpretador.
 * Isso tem sua cota de problemas, sobretudo porque a avaliação insere e descarta escopos,
 * entrando em condição de corrida com a interpretação com depuração.
 * Método usado principalmente pela [extensão do Visual Studio Code](https://github.com/DesignLiquido/vscode)
 * e pelo mecanismo de depuração remota, implementado em [`delegua-node`](https://github.com/DesignLiquido/delegua-node).
 * @param nome O nome da variável.
 */
export declare function obterVariavel(interpretador: InterpretadorComDepuracaoInterface, nome: string): any;
//# sourceMappingURL=comum.d.ts.map