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

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

import { AcessoMetodoOuPropriedade, Chamada, Construto, Dicionario, FuncaoConstruto, Leia } from '../../construtos';
import { ParametroInterface, SimboloInterface } from '../../interfaces';
import { ErroAvaliadorSintatico } from './../erro-avaliador-sintatico';
import { Tupla } from '../../construtos/tuplas';
import { Comentario, Continua, Declaracao, Enquanto, Escreva, Expressao, FuncaoDeclaracao, Para, ParaCada, Retorna, Se, Sustar, Var } from '../../declaracoes';
import { RetornoAvaliadorSintatico } from '../../interfaces/retornos/retorno-avaliador-sintatico';
import { RetornoLexador } from '../../interfaces/retornos/retorno-lexador';
import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
import { PilhaEscopos } from './../pilha-escopos';
import { InformacaoVariavelOuConstante } from '../../informacao-variavel-ou-constante';
/**
 * 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]: InformacaoVariavelOuConstante;
    };
    hashArquivo: number;
    atual: number;
    blocos: number;
    performance: boolean;
    superclasseAtual: string | undefined;
    constructor(performance?: boolean);
    protected verificarDefinicaoTipoAtual(): string;
    protected obterChaveDicionario(): Construto;
    protected construtoDicionario(simboloChaveEsquerda: SimboloInterface): Dicionario;
    protected construtoTupla(): Tupla;
    primario(): Construto;
    chamar(): Construto;
    /**
     * `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 {Construto} O construto resolvido como um tipo mais específico.
     * @see finalizarChamada
     */
    protected resolverEntidadeChamadaAcessoMetodoOuPropriedade(entidadeChamadaResolvida: AcessoMetodoOuPropriedade): Construto;
    protected validarArgumentosEntidadeChamada(argumentosEntidadeChamada: InformacaoVariavelOuConstante[], argumentosUtilizados: Construto[]): 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: Construto, argumentos: Construto[], tipoPrimitiva?: string | undefined): Construto;
    protected declaracaoDeFuncao(identificador: SimboloInterface<string>): FuncaoDeclaracao;
    finalizarChamada(entidadeChamada: Construto, tipoPrimitiva?: string | undefined): Chamada;
    unario(): Construto;
    multiplicar(): Construto;
    /**
     * 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(): Construto;
    bitShift(): Construto;
    bitE(): Construto;
    bitOu(): Construto;
    comparar(): Construto;
    comparacaoIgualdade(): Construto;
    em(): Construto;
    e(): Construto;
    /**
     * Método que resolve atribuições.
     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
     */
    atribuir(): Construto;
    /**
     * Declaração para comando `leia`, para ler dados de entrada do usuário.
     * @returns Um objeto da classe `Leia`.
     */
    expressaoLeia(): Leia;
    expressao(): Construto;
    blocoEscopo(tipo?: string): Array<Declaracao>;
    protected declaracaoComentarioUmaLinha(): Comentario;
    declaracaoContinua(): Continua;
    declaracaoEnquanto(): Enquanto;
    declaracaoEscreva(): Escreva;
    protected declaracaoExpressao(): Expressao;
    declaracaoPara(): Para | ParaCada;
    protected declaracaoParaCada(simboloParaCada: SimboloInterface, simboloVariavelIteracao: SimboloInterface, literalOuVariavelIteravel: Construto): ParaCada;
    protected declaracaoParaTradicional(simboloPara: SimboloInterface, simboloVariavelIteracao: SimboloInterface, literalOuVariavelInicio: Construto): Para;
    declaracaoRetorna(): Retorna;
    declaracaoSe(): 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(): Declaracao | Declaracao[];
    protected logicaComumInferenciaTiposVariaveis(inicializador: Construto): 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(): Var | FuncaoDeclaracao;
    protected logicaComumParametros(): ParametroInterface[];
    corpoDaFuncao(tipo: 'função' | 'implícita'): 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(): 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: RetornoLexador<SimboloInterface>, hashArquivo: number): RetornoAvaliadorSintatico<Declaracao>;
}
//# sourceMappingURL=avaliador-sintatico-tenda.d.ts.map