@designliquido/delegua/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.d.ts

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

import { FuncaoConstruto, Leia } from '../../construtos';
import { ConstrutoInterface } from '../../interfaces/construtos/construto-interface';
import { Declaracao, Enquanto, Escolha, Escreva, Fazer, Para, Se } from '../../declaracoes';
import { RetornoLexadorInterface, RetornoAvaliadorSintaticoInterface } from '../../interfaces/retornos';
import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
import { SimboloInterface } from '../../interfaces';
export declare class AvaliadorSintaticoPortugolIpt extends AvaliadorSintaticoBase {
    private simboloAtualEh;
    private fechamentoEnquantoAtual;
    private consumirFechamentoEnquanto;
    private fechamentoEscolheAtual;
    private consumirFechamentoEscolhe;
    private avaliarExpressaoNumericaConstante;
    /**
     * Consome quebras de linha opcionais.
     */
    private consumirQuebrasLinha;
    /**
     * Coleta declarações até encontrar um token cujo tipo esteja em `tiposParada`.
     * O token de parada NÃO é consumido.
     */
    private resolverBloco;
    primario(): Promise<ConstrutoInterface>;
    /**
     * Suporta chamadas de funções embutidas: SEN(x), COS(x), POTENCIA(b,e), etc.
     */
    chamar(): Promise<ConstrutoInterface>;
    /**
     * Override de `unario()` para incluir operadores unários aritméticos.
     * `NAO` é tratado em `e()` para ter precedência menor que comparações.
     */
    protected unario(): Promise<ConstrutoInterface>;
    /**
     * Override de `e()` para suportar o operador lógico `NAO` com precedência
     * menor que comparações: `nao x = 0` → `nao (x = 0)`.
     */
    protected e(): Promise<ConstrutoInterface>;
    /**
     * Override de `ou()` para incluir o operador lógico `XOU`.
     */
    protected ou(): Promise<ConstrutoInterface>;
    atribuir(): Promise<ConstrutoInterface>;
    /**
     * `escrever expr [, expr ...]`
     */
    declaracaoEscreva(): Promise<Escreva>;
    /**
     * `se cond entao ... [senao ...] fimse`
     */
    declaracaoSe(): Promise<Se>;
    /**
     * `enquanto cond faz ... fimenquanto`
     */
    declaracaoEnquanto(): Promise<Enquanto>;
    /**
     * `para v de ini ate fim [passo p]` + corpo + `proximo`
     */
    declaracaoPara(): Promise<Para>;
    /**
     * `repete ... ate cond`
     * Semântica: executa o corpo e repete enquanto a condição for FALSA (repeat-until).
     * Mapeado para `Fazer` com a condição invertida via `nao`.
     */
    private declaracaoRepete;
    /**
     * `faz ... enquanto cond`
     * O `enquanto` de fechamento é distinguido no lexer (FAZENQUANTO) do `enquanto` de abertura.
     */
    declaracaoFazer(): Promise<Fazer>;
    /**
     * `escolhe expr caso v[, v...]: instr ... [defeito: instr] fimescolhe`
     */
    declaracaoEscolha(): Escolha;
    private declaracaoEscolhaAsync;
    /**
     * `ler var [, var ...]`
     */
    expressaoLeia(): Promise<Leia>;
    /**
     * Declara variáveis de um dado tipo, com suporte a arrays e valor inicial.
     * Ex: `inteiro x`, `real y = 3.14`, `logico v[5]`
     */
    private declaracaoVariaveis;
    /**
     * `constante tipo nome = valor`
     */
    private declaracaoConstante;
    resolverDeclaracaoForaDeBloco(): Promise<Declaracao | Declaracao[]>;
    blocoEscopo(): Promise<Declaracao[]>;
    corpoDaFuncao(_tipo: string): Promise<FuncaoConstruto>;
    analisar(retornoLexador: RetornoLexadorInterface<SimboloInterface>, hashArquivo: number): Promise<RetornoAvaliadorSintaticoInterface<Declaracao>>;
}
//# sourceMappingURL=avaliador-sintatico-portugol-ipt.d.ts.map