@designliquido/delegua/avaliador-sintatico/avaliador-sintatico-base.d.ts

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

import { Chamada, FuncaoConstruto, Leia } from '../construtos';
import { Bloco, Classe, Continua, Declaracao, Enquanto, Escreva, Expressao, FuncaoDeclaracao, Para, ParaCada, Retorna, Se, Sustar, Tente, Var } from '../declaracoes';
import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
import { ConstrutoInterface } from '../interfaces/construtos/construto-interface';
import { RetornoAvaliadorSintaticoInterface, RetornoLexadorInterface } from '../interfaces/retornos';
import { ErroAvaliadorSintatico } from './erro-avaliador-sintatico';
/**
 * O Avaliador Sintático Base é uma tentativa de mapear métodos em comum
 * entre todos os outros Avaliadores Sintáticos. Depende de um dicionário
 * de tipos de símbolos comuns entre todos os dialetos.
 */
export declare abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterface<SimboloInterface, Declaracao> {
    simbolos: SimboloInterface[];
    erros: ErroAvaliadorSintatico[];
    hashArquivo: number;
    atual: number;
    blocos: number;
    erro(simbolo: SimboloInterface, mensagemDeErro: string, codigoDiagnostico?: string, simboloRelacionado?: SimboloInterface): ErroAvaliadorSintatico;
    protected consumir(tipo: string, mensagemDeErro: string): SimboloInterface;
    protected simboloAnterior(): SimboloInterface;
    protected verificarTipoSimboloAtual(tipo: string): boolean;
    protected verificarTipoProximoSimbolo(tipo: string): boolean;
    protected estaNoFinal(): boolean;
    protected avancarEDevolverAnterior(): SimboloInterface;
    protected verificarSeSimboloAtualEIgualA(...argumentos: string[]): boolean;
    /**
     * Os métodos a seguir devem ser implementados nos seus respectivos
     * dialetos por diferentes razões: seja porque o dialeto correspondente
     * tem uma abordagem diferente sobre entrada e saída, seja porque a
     * funcionalidade sequer existe, mas é suprimida por outra.
     *
     * Esses métodos não precisam ser expostos. A recomendação geral é
     * implementá-los como `protected`.
     */
    protected abstract atribuir(): Promise<ConstrutoInterface>;
    protected abstract blocoEscopo(): Promise<Declaracao[]>;
    protected abstract chamar(): Promise<ConstrutoInterface>;
    protected abstract corpoDaFuncao(tipo: string): Promise<FuncaoConstruto>;
    protected abstract declaracaoEnquanto(): Promise<Enquanto>;
    protected abstract declaracaoEscreva(): Promise<Escreva>;
    protected abstract declaracaoPara(): Promise<Para | ParaCada>;
    protected abstract declaracaoSe(): Promise<Se>;
    protected abstract expressaoLeia(): Promise<Leia>;
    protected abstract primario(): Promise<ConstrutoInterface>;
    protected abstract resolverDeclaracaoForaDeBloco(): Promise<Declaracao | Declaracao[] | undefined>;
    protected declaracaoBloco(): Promise<Bloco>;
    protected finalizarChamada(entidadeChamada: ConstrutoInterface): Promise<Chamada>;
    protected unario(): Promise<ConstrutoInterface>;
    /**
     * A exponenciacão é uma exceção na ordem de avaliação (resolve primeiro à direita).
     * Por isso `direito` chama `exponenciacao()`, e não `unario()`.
     * @returns {Binario} A expressão binária na forma do construto `Binario`.
     */
    protected exponenciacao(): Promise<ConstrutoInterface>;
    protected multiplicar(): Promise<ConstrutoInterface>;
    protected adicaoOuSubtracao(): Promise<ConstrutoInterface>;
    /**
     * Este método é usado por Delégua e alguns dialetos de Portugol que possuem declarações
     * de múltiplas variáveis na mesma linha.
     */
    protected declaracaoDeVariaveis(): Promise<Var[]>;
    protected comparar(): Promise<ConstrutoInterface>;
    protected comparacaoIgualdade(): Promise<ConstrutoInterface>;
    protected e(): Promise<ConstrutoInterface>;
    protected ou(): Promise<ConstrutoInterface>;
    /**
     * Processa tuplas, que são expressões separadas por vírgula entre parênteses.
     * Se não houver vírgula, retorna apenas a expressão simples.
     */
    protected tupla(): Promise<ConstrutoInterface>;
    protected expressao(): Promise<ConstrutoInterface>;
    protected funcao(tipo: string): Promise<FuncaoDeclaracao>;
    protected logicaComumParametros(): Promise<ParametroInterface[]>;
    /**
     * Os métodos a seguir só devem ser implementados se o dialeto
     * em questão realmente possui a funcionalidade, e devem levantar
     * erro em caso contrário.
     */
    protected bitShift(): Promise<ConstrutoInterface>;
    protected bitE(): Promise<ConstrutoInterface>;
    protected bitOu(): Promise<ConstrutoInterface>;
    protected declaracaoContinua(): Continua;
    protected declaracaoDeClasse(): Promise<Classe>;
    protected declaracaoDeVariavel(): Var;
    protected declaracaoExpressao(simboloAnterior?: SimboloInterface): Promise<Expressao>;
    protected declaracaoRetorna(): Promise<Retorna>;
    protected declaracaoSustar(): Sustar;
    protected declaracaoTente(): Promise<Tente>;
    protected em(): Promise<ConstrutoInterface>;
    protected resolverDeclaracao(): void;
    /**
     * Este é o ponto de entrada de toda a avaliação sintática. É o
     * único método mencionado na interface do avaliador sintático, e cada
     * avaliador sintático deve implementar o seu método.
     * @param retornoLexador O retorno do Lexador.
     * @param hashArquivo O hash do arquivo, gerado pela função `cyrb53`.
     * @see cyrb53
     */
    abstract analisar(retornoLexador: RetornoLexadorInterface<SimboloInterface>, hashArquivo: number): Promise<RetornoAvaliadorSintaticoInterface<Declaracao>>;
}
//# sourceMappingURL=avaliador-sintatico-base.d.ts.map