@designliquido/delegua/tradutores/tradutor-webassembly.d.ts

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

import { AcessoIndiceVariavel, AcessoMetodo, Agrupamento, AtribuicaoPorIndice, Atribuir, Binario, Chamada, DefinirValor, FuncaoConstruto, Literal, Logico, TipoDe, Unario, Variavel, Vetor } from '../construtos';
import { Bloco, Classe, Const, Continua, Declaracao, Enquanto, Escolha, Escreva, EscrevaMesmaLinha, Expressao, Falhar, Fazer, FuncaoDeclaracao, Importar, Para, ParaCada, Retorna, Se, Sustar, Tente, Var } from '../declaracoes';
export declare class TradutorWebAssembly {
    /** Segmentos de dados estáticos para strings literais */
    private segmentosTexto;
    /** Próximo byte livre na memória linear para strings */
    private deslocamentoTexto;
    /** Texto WAT completo de cada função declarada pelo usuário */
    private funcoesCompletas;
    /** Declarações WAT de variáveis globais `(global ...)` */
    private declaracoesGlobais;
    /** Instruções WAT emitidas no corpo da função corrente */
    private corpoDaFuncaoAtual;
    /** Declarações `(param ...)` e `(local ...)` da função corrente */
    private declaracoesLocaisAtual;
    /** Nomes de locais/params já declarados (evita duplicatas) */
    private locaisDeclaradosAtual;
    /** Estamos dentro do corpo de uma função nomeada? */
    private dentroFuncao;
    /** A função corrente possui ao menos um `retorna` com valor? */
    private funcaoTemRetorno;
    /** Nome Delégua → metadados WAT */
    private variaveis;
    /** Pilha de rótulos de laço para `sustar`/`continua` */
    private pilhaDeControle;
    private contadorRotulos;
    private gerarRotulo;
    /** Emite uma instrução indentada no corpo da função corrente. */
    private emitir;
    /**
     * Converte uma string JavaScript para bytes UTF-8.
     * Usa `encodeURIComponent` para extrair os bytes — funciona em qualquer ambiente JS
     * sem depender de APIs específicas de Node.js (Buffer) ou browser (TextEncoder).
     */
    private stringParaBytesUtf8;
    /**
     * Converte uma string JavaScript para o formato de literal de string WAT.
     * Bytes não-ASCII e caracteres especiais são hex-escapados como `\xx`.
     * Retorna o literal pronto para uso em `(data ...)` e o comprimento em bytes UTF-8.
     */
    private escaparStringWat;
    /**
     * Internaliza uma string literal na memória linear estática.
     * Strings idênticas são deduplicadas.
     * O comprimento armazenado é o comprimento em bytes UTF-8, não em caracteres.
     */
    private internalizarTexto;
    /**
     * Infere o tipo WAT de um construto.
     * Strings → i32 (ponteiro). Tudo mais → i64 (padrão, inclusive booleanos).
     */
    private inferirTipo;
    /**
     * Declara um parâmetro ou variável local para a função corrente.
     * `ehParam = true` emite `(param ...)`, senão `(local ...)`.
     */
    private declararParamLocal;
    /** Salva o contexto da função corrente e inicializa um novo. */
    private salvarEIniciarContextoFuncao;
    /** Restaura o contexto de função a partir de um snapshot. */
    private restaurarContextoFuncao;
    /**
     * Garante que uma variável existe no escopo correto.
     * Retorna o nome WAT da variável (e.g. `$x`).
     */
    private garantirVariavel;
    private traduzirConstruto;
    private traduzirDeclaracaoInterna;
    dicionarioConstrutos: {
        AcessoIndiceVariavel: any;
        AcessoMetodoOuPropriedade: any;
        Agrupamento: any;
        AtribuicaoPorIndice: any;
        Atribuir: any;
        Binario: any;
        Chamada: any;
        DefinirValor: any;
        FuncaoConstruto: any;
        Literal: any;
        Logico: any;
        TipoDe: any;
        Unario: any;
        Variavel: any;
        Vetor: any;
    };
    dicionarioDeclaracoes: {
        Bloco: any;
        Classe: any;
        Const: any;
        Continua: any;
        Enquanto: any;
        Escolha: any;
        Escreva: any;
        EscrevaMesmaLinha: any;
        Expressao: any;
        Falhar: any;
        Fazer: any;
        FuncaoDeclaracao: any;
        Importar: any;
        Para: any;
        ParaCada: any;
        Retorna: any;
        Se: any;
        Sustar: any;
        Tente: any;
        Var: any;
    };
    traduzirLiteral(construto: Literal): string;
    traduzirVariavel(construto: Variavel): string;
    traduzirAtribuir(construto: Atribuir): string;
    traduzirBinario(construto: Binario): string;
    traduzirLogico(construto: Logico): string;
    traduzirUnario(construto: Unario): string;
    traduzirAgrupamento(construto: Agrupamento): string;
    traduzirChamada(construto: Chamada): string;
    traduzirAcessoIndiceVariavel(construto: AcessoIndiceVariavel): string;
    traduzirAtribuicaoPorIndice(construto: AtribuicaoPorIndice): string;
    traduzirVetor(construto: Vetor): string;
    traduzirDefinirValor(construto: DefinirValor): string;
    traduzirFuncaoConstruto(construto: FuncaoConstruto): string;
    traduzirAcessoMetodo(_construto: AcessoMetodo): string;
    traduzirTipoDe(construto: TipoDe): string;
    traduzirVar(declaracao: Var): void;
    traduzirConst(declaracao: Const): void;
    /**
     * Traduz um literal para um WAT const-expr válido como inicializador de global.
     * Apenas literais são aceitos como inicializadores de globais em WAT.
     */
    private traduzirGlobalInit;
    traduzirSe(declaracao: Se): void;
    traduzirEnquanto(declaracao: Enquanto): void;
    traduzirPara(declaracao: Para): void;
    traduzirFazer(declaracao: Fazer): void;
    traduzirEscolha(declaracao: Escolha): void;
    private emitirCadeiaEscolha;
    traduzirBloco(declaracao: Bloco): void;
    traduzirExpressao(declaracao: Expressao): void;
    traduzirEscreva(declaracao: Escreva | EscrevaMesmaLinha): void;
    traduzirRetorna(declaracao: Retorna): void;
    traduzirSustar(_declaracao: Sustar): void;
    traduzirContinua(_declaracao: Continua): void;
    traduzirFuncaoDeclaracao(declaracao: FuncaoDeclaracao): void;
    traduzirFalhar(declaracao: Falhar): void;
    traduzirImportar(_declaracao: Importar): void;
    traduzirTente(declaracao: Tente): void;
    traduzirClasse(_declaracao: Classe): void;
    traduzirParaCada(declaracao: ParaCada): void;
    /**
     * Traduz uma lista de declarações Delégua para um módulo WAT.
     * Retorna a string completa do módulo.
     */
    traduzir(declaracoes: Declaracao[]): string;
    /**
     * Gera um arquivo `.mjs` host para executar o módulo WASM no Node.js.
     * Fornece os imports necessários (`delegua.escreva_texto`, `delegua.escreva_inteiro`).
     */
    gerarArquivoHost(): string;
}
//# sourceMappingURL=tradutor-webassembly.d.ts.map