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

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

import { Chamada, Construto, FuncaoConstruto, Leia, ImportarComoConstruto } from '../../construtos';
import { Escreva, Escolha, ParaCada, Se, Tente, Enquanto, Para, Continua, Retorna, Importar, Var, FuncaoDeclaracao, Classe, Declaracao, Expressao, Sustar } from '../../declaracoes';
import { ParametroInterface, SimboloInterface } from '../../interfaces';
import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
import { RetornoLexador } from '../../interfaces/retornos/retorno-lexador';
import { ErroAvaliadorSintatico } from '../erro-avaliador-sintatico';
import { RetornoAvaliadorSintatico } from '../../interfaces/retornos/retorno-avaliador-sintatico';
import { PilhaEscopos } from '../pilha-escopos';
import { InformacaoElementoSintatico } from '../../informacao-elemento-sintatico';
/**
 * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
 * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
 * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
 *
 * Este avaliador sintático é específico para o dialeto Prisma da linguagem Delégua.
 */
export declare class AvaliadorSintaticoPrisma extends AvaliadorSintaticoBase {
    simbolos: SimboloInterface[];
    erros: ErroAvaliadorSintatico[];
    tiposDefinidosEmCodigo: {
        [nomeTipo: string]: Declaracao;
    };
    pilhaEscopos: PilhaEscopos;
    primitivasConhecidas: {
        [nomeModuloOuClasse: string]: {
            [nomePrimitiva: string]: InformacaoElementoSintatico;
        };
    };
    hashArquivo: number;
    atual: number;
    blocos: number;
    performance: boolean;
    superclasseAtual: string | undefined;
    constructor(performance?: boolean);
    sincronizar(): void;
    consumir(tipo: string, mensagemDeErro: string): SimboloInterface;
    simboloNaPosicao(posicao: number): SimboloInterface;
    avancarEDevolverAnterior(): SimboloInterface<string>;
    verificarSeSimboloAtualEIgualA(...argumentos: string[]): boolean;
    primario(): Promise<Construto>;
    expressaoImportar(): Promise<ImportarComoConstruto>;
    /**
     * Construto para texto multilinhas.
     * @returns
     */
    construtoTextoMultilinhas(): Construto;
    expressaoLeia(): Promise<Leia>;
    protected finalizarChamada(entidadeChamada: Construto): Promise<Chamada>;
    chamar(): Promise<Construto>;
    unario(): Promise<Construto>;
    exponenciacao(): Promise<Construto>;
    multiplicar(): Promise<Construto>;
    adicaoOuSubtracao(): Promise<Construto>;
    concatenacao(): Promise<Construto>;
    bitShift(): Promise<Construto>;
    bitE(): Promise<Construto>;
    bitOu(): Promise<Construto>;
    comparar(): Promise<Construto>;
    comparacaoIgualdade(): Promise<Construto>;
    em(): Promise<Construto>;
    e(): Promise<Construto>;
    ou(): Promise<Construto>;
    ternario(): Promise<Construto>;
    atribuir(): Promise<Construto>;
    expressao(): Promise<Construto>;
    declaracaoEscreva(): Promise<Escreva>;
    declaracaoExpressao(): Promise<Expressao>;
    protected blocoEscopo(): Promise<any[]>;
    declaracaoDeLocal(): Promise<Var>;
    declaracaoEnquanto(): Promise<Enquanto>;
    declaracaoEscolha(): Promise<Escolha>;
    declaracaoSe(): Promise<Se>;
    declaracaoTente(): Promise<Tente>;
    declaracaoQuebre(): Promise<Sustar>;
    declaracaoContinua(): Continua;
    declaracaoRetorna(): Promise<Retorna>;
    declaracaoImportar(): Promise<Importar>;
    corpoDaFuncao(tipo: string): Promise<FuncaoConstruto>;
    protected logicaComumParametros(): Promise<ParametroInterface[]>;
    funcao(tipo: string): Promise<FuncaoDeclaracao>;
    resolverDeclaracao(): Promise<Declaracao>;
    declaracaoOuAtribuicaoVariaveis(): Promise<Var | Expressao>;
    /**
     * Segundo o manual de Prisma, os tipos válidos para a linguagem são:
     *  número, string , tabela, funcao , userdata, boolean, nulo.
     * @param inicializador O construto do inicializador.
     * @param tipoPrevio Se há um tipo prévio definido. `qualquer` não é válido em Prisma:
     *                   O tipo sempre resolve para algum outro.
     * @returns O tipo inferido.
     */
    protected logicaComumInferenciaTiposVariaveisEConstantes(inicializador: Construto, tipoPrevio: string): string;
    declaracaoParaCada(simboloPara: SimboloInterface): Promise<ParaCada>;
    declaracaoPara(): Promise<Para | ParaCada>;
    resolverDeclaracaoForaDeBloco(): Promise<Declaracao | null>;
    metodoClassePrisma(construtor: boolean): Promise<FuncaoDeclaracao>;
    private propriedadesDeclaradasEmMetodo;
    declaracaoDeClasse(): Promise<Classe>;
    protected inicializarPilhaEscopos(): void;
    analisar(retornoLexador: RetornoLexador<SimboloInterface>, hashArquivo: number): Promise<RetornoAvaliadorSintatico<Declaracao>>;
}
//# sourceMappingURL=avaliador-sintatico-prisma.d.ts.map