@designliquido/delegua/avaliador-sintatico/dialetos/avaliador-sintatico-tenda.d.ts

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

import { AcessoMetodoOuPropriedade, Chamada, Dicionario, FuncaoConstruto, Leia, Tupla } from '../../construtos';
import { ConstrutoInterface, ParametroInterface, SimboloInterface } from '../../interfaces';
import { ErroAvaliadorSintatico } from './../erro-avaliador-sintatico';
import { Comentario, Continua, Declaracao, Enquanto, Escreva, Expressao, FuncaoDeclaracao, Para, ParaCada, Retorna, Se, Sustar, Var } from '../../declaracoes';
import { RetornoAvaliadorSintaticoInterface } from '../../interfaces/retornos/retorno-avaliador-sintatico-interface';
import { RetornoLexadorInterface } from '../../interfaces/retornos/retorno-lexador-interface';
import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
import { PilhaEscopos } from './../pilha-escopos';
import { InformacaoElementoSintatico } from '../../informacao-elemento-sintatico';
/**
 * Este avaliador sintático emite todos os símbolos de Tenda. No entanto, nem todo
 * símbolo emitido aqui pode ser interpretado por este núcleo, já que Tenda tem
 * Rust como base, e várias de suas funções requerem interface com um sistema operacional.
 * Outros pacotes do ecossistema de Delégua, como `delegua-node` poderão lidar com
 * todas as funcionalidades de Tenda.
 */
export declare class AvaliadorSintaticoTenda extends AvaliadorSintaticoBase {
    simbolos: SimboloInterface[];
    erros: ErroAvaliadorSintatico[];
    tiposDefinidosEmCodigo: {
        [key: string]: Declaracao;
    };
    pilhaEscopos: PilhaEscopos;
    tiposDeFerramentasExternas: {
        [key: string]: {
            [key: string]: string;
        };
    };
    primitivasConhecidas: {
        [key: string]: InformacaoElementoSintatico;
    };
    hashArquivo: number;
    atual: number;
    blocos: number;
    performance: boolean;
    superclasseAtual: string | undefined;
    constructor(performance?: boolean);
    protected verificarDefinicaoTipoAtual(): string;
    protected obterChaveDicionario(): Promise<ConstrutoInterface>;
    protected construtoDicionario(simboloChaveEsquerda: SimboloInterface): Promise<Dicionario>;
    protected construtoTupla(): Promise<Tupla>;
    primario(): Promise<ConstrutoInterface>;
    chamar(): Promise<ConstrutoInterface>;
    /**
     * `AcessoMetodoOuPropriedade` é um construto intermediário em Delégua, e deve ser resolvido como outro
     * construto antes de qualquer outra próxima etapa. Algumas validações adicionais também ocorrem aqui.
     * @param {AcessoMetodoOuPropriedade} entidadeChamadaResolvida O construto original.
     * @returns {ConstrutoInterface} O construto resolvido como um tipo mais específico.
     * @see finalizarChamada
     */
    protected resolverEntidadeChamadaAcessoMetodoOuPropriedade(entidadeChamadaResolvida: AcessoMetodoOuPropriedade): ConstrutoInterface;
    protected validarArgumentosEntidadeChamada(argumentosEntidadeChamada: InformacaoElementoSintatico[], argumentosUtilizados: ConstrutoInterface[]): string[];
    /**
     * Diversas verificações de resolução de entidade chamada, como resolver chamada da pilha ou usar referência, argumentos, etc.
     * @param entidadeChamada O construto da entidade chamada.
     * @param argumentos Os argumentos utilizados na chamada.
     * @param tipoPrimitiva Se for uma primitiva, o tipo dela. Senão, `undefined`.
     * @returns A entidade chamada resolvida, se as validações passarem.
     */
    protected resolverEntidadeChamada(entidadeChamada: ConstrutoInterface, argumentos: ConstrutoInterface[], tipoPrimitiva?: string | undefined): ConstrutoInterface;
    protected declaracaoDeFuncao(identificador: SimboloInterface<string>): Promise<FuncaoDeclaracao>;
    finalizarChamada(entidadeChamada: ConstrutoInterface, tipoPrimitiva?: string | undefined): Promise<Chamada>;
    unario(): Promise<ConstrutoInterface>;
    multiplicar(): Promise<ConstrutoInterface>;
    /**
     * Se símbolo de operação é `+`, `-`, `+=` ou `-=`, monta objeto `Binario` para
     * ser avaliado pelo Interpretador.
     * @returns Um Construto, normalmente um `Binario`, ou `Unario` se houver alguma operação unária para ser avaliada.
     */
    adicaoOuSubtracao(): Promise<ConstrutoInterface>;
    bitShift(): Promise<ConstrutoInterface>;
    bitE(): Promise<ConstrutoInterface>;
    bitOu(): Promise<ConstrutoInterface>;
    comparar(): Promise<ConstrutoInterface>;
    comparacaoIgualdade(): Promise<ConstrutoInterface>;
    em(): Promise<ConstrutoInterface>;
    e(): Promise<ConstrutoInterface>;
    /**
     * Método que resolve atribuições.
     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
     */
    atribuir(): Promise<ConstrutoInterface>;
    /**
     * Declaração para comando `leia`, para ler dados de entrada do usuário.
     * @returns Um objeto da classe `Leia`.
     */
    expressaoLeia(): Promise<Leia>;
    blocoEscopo(tipo?: string): Promise<Array<Declaracao>>;
    protected declaracaoComentarioUmaLinha(): Comentario;
    declaracaoContinua(): Continua;
    declaracaoEnquanto(): Promise<Enquanto>;
    declaracaoEscreva(): Promise<Escreva>;
    protected declaracaoExpressao(): Promise<Expressao>;
    declaracaoPara(): Promise<Para | ParaCada>;
    protected declaracaoParaCada(simboloParaCada: SimboloInterface, simboloVariavelIteracao: SimboloInterface, literalOuVariavelIteravel: ConstrutoInterface): Promise<ParaCada>;
    protected declaracaoParaTradicional(simboloPara: SimboloInterface, simboloVariavelIteracao: SimboloInterface, literalOuVariavelInicio: ConstrutoInterface): Promise<Para>;
    declaracaoRetorna(): Promise<Retorna>;
    declaracaoSe(): Promise<Se>;
    declaracaoSustar(): Sustar;
    /**
     * Todas as resoluções triviais da linguagem, ou seja, todas as
     * resoluções que podem ocorrer dentro ou fora de um bloco.
     * @returns Normalmente uma `Declaracao`, mas há casos em que
     * outros objetos podem ser retornados.
     * @see resolverDeclaracaoForaDeBloco para as declarações que não podem
     * ocorrer em blocos de escopo elementares.
     */
    protected resolverDeclaracao(): Promise<Declaracao | Declaracao[]>;
    protected logicaComumInferenciaTiposVariaveis(inicializador: ConstrutoInterface): string;
    /**
     * Após palavra reservada `seja`, é esperado ou uma variável, ou uma função.
     * @returns Um Construto, ou do tipo `Var` para variável, ou do tipo `FuncaoDeclaracao` se for
     *          declaração de função.
     */
    protected declaracaoDeVariaveisOuFuncoes(): Promise<Var | FuncaoDeclaracao>;
    protected logicaComumParametros(): Promise<ParametroInterface[]>;
    corpoDaFuncao(tipo: 'função' | 'implícita'): Promise<FuncaoConstruto>;
    /**
     * Até então, Tenda não tem casos de declarações fora de blocos.
     * Isso pode mudar futuramente. Portanto, esta seção será mantida.
     * @returns Uma `Declaracao` ou várias, dependendo do retorno de `resolverDeclaracao`.
     * @see resolverDeclaracao
     */
    resolverDeclaracaoForaDeBloco(): Promise<Declaracao | Declaracao[]>;
    /**
     * Usado quando há erros na avaliação sintática.
     * Garante que o código não entre em loop infinito.
     * @returns Sempre retorna `void`.
     */
    protected sincronizar(): void;
    /**
     * Inicializa o primeiro nível da pilha de escopos, normalmente com ítens da biblioteca global.
     */
    protected inicializarPilhaEscopos(): void;
    analisar(retornoLexador: RetornoLexadorInterface<SimboloInterface>, hashArquivo: number): Promise<RetornoAvaliadorSintaticoInterface<Declaracao>>;
}
//# sourceMappingURL=avaliador-sintatico-tenda.d.ts.map