@designliquido/delegua 1.13.2 → 1.14.0

package/tradutores/tradutor-assembly-risc-v.js

@@ -0,0 +1,685 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradutorAssemblyRISCV = void 0;
+const construtos_1 = require("../construtos");
+const declaracoes_1 = require("../declaracoes");
+class TradutorAssemblyRISCV {
+    constructor(alvo = 'linux-rv64') {
+        this.alvo = alvo;
+        this.indentacao = 0;
+        this.contadorLabels = 0;
+        this.variaveis = new Map();
+        // s2-s9 são callee-saved — seguros para usar como scratch entre chamadas
+        this.registradoresDisponiveis = ['s2', 's3', 's4', 's5', 's6', 's7', 's8', 's9'];
+        this.pilhaRegistradores = [];
+        this.bss = '.bss\n';
+        this.data = '.data\n';
+        this.dicionarioConstrutos = {
+            AcessoIndiceVariavel: this.traduzirAcessoIndiceVariavel.bind(this),
+            AcessoMetodoOuPropriedade: this.traduzirConstrutoAcessoMetodo.bind(this),
+            Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
+            AtribuicaoPorIndice: this.traduzirConstrutoAtribuicaoPorIndice.bind(this),
+            Atribuir: this.traduzirConstrutoAtribuir.bind(this),
+            Binario: this.traduzirConstrutoBinario.bind(this),
+            Chamada: this.traduzirConstrutoChamada.bind(this),
+            DefinirValor: this.traduzirConstrutoDefinirValor.bind(this),
+            FuncaoConstruto: this.traduzirFuncaoConstruto.bind(this),
+            Isto: () => 'this',
+            Literal: this.traduzirConstrutoLiteral.bind(this),
+            Logico: this.traduzirConstrutoLogico.bind(this),
+            TipoDe: this.traduzirConstrutoTipoDe.bind(this),
+            Unario: this.traduzirConstrutoUnario.bind(this),
+            Variavel: this.traduzirConstrutoVariavel.bind(this),
+            Vetor: this.traduzirConstrutoVetor.bind(this),
+        };
+        this.dicionarioDeclaracoes = {
+            Bloco: this.traduzirDeclaracaoBloco.bind(this),
+            Enquanto: this.traduzirDeclaracaoEnquanto.bind(this),
+            Continua: () => 'j .continue_label',
+            Escolha: this.traduzirDeclaracaoEscolha.bind(this),
+            Escreva: this.traduzirDeclaracaoEscreva.bind(this),
+            Expressao: this.traduzirDeclaracaoExpressao.bind(this),
+            Fazer: this.traduzirDeclaracaoFazer.bind(this),
+            Falhar: this.traduzirDeclaracaoFalhar.bind(this),
+            FuncaoDeclaracao: this.traduzirDeclaracaoFuncao.bind(this),
+            Importar: this.traduzirDeclaracaoImportar.bind(this),
+            Leia: this.traduzirDeclaracaoLeia.bind(this),
+            Para: this.traduzirDeclaracaoPara.bind(this),
+            ParaCada: this.traduzirDeclaracaoParaCada.bind(this),
+            Retorna: this.traduzirDeclaracaoRetorna.bind(this),
+            Se: this.traduzirDeclaracaoSe.bind(this),
+            Sustar: () => 'j .break_label',
+            Classe: this.traduzirDeclaracaoClasse.bind(this),
+            Tente: this.traduzirDeclaracaoTente.bind(this),
+            Const: this.traduzirDeclaracaoConst.bind(this),
+            Var: this.traduzirDeclaracaoVar.bind(this),
+        };
+        this.indentacao = 0;
+        this.text = `
+.text
+.global _start
+
+_start:`;
+    }
+    gerarDigitoAleatorio() {
+        let result = '';
+        const digits = '0123456789';
+        for (let i = 0; i < 5; i++) {
+            const randomIndex = Math.floor(Math.random() * digits.length);
+            result += digits.charAt(randomIndex);
+        }
+        return result;
+    }
+    gerarLabel() {
+        return `.L${this.contadorLabels++}`;
+    }
+    obterRegistrador() {
+        if (this.registradoresDisponiveis.length > 0) {
+            const reg = this.registradoresDisponiveis.pop();
+            this.pilhaRegistradores.push(reg);
+            return reg;
+        }
+        return 'a0'; // fallback
+    }
+    liberarRegistrador(reg) {
+        const index = this.pilhaRegistradores.indexOf(reg);
+        if (index > -1) {
+            this.pilhaRegistradores.splice(index, 1);
+            this.registradoresDisponiveis.push(reg);
+        }
+    }
+    // Emite a instrução de carga correta para o registrador destino.
+    // RISC-V não tem um `ldr reg, =value` polimórfico como ARM —
+    // usa `li` para inteiros e `la` para endereços de símbolos.
+    emitirCarga(registrador, valor) {
+        if (valor === registrador)
+            return;
+        if (valor === 'null') {
+            this.text += `\n    li ${registrador}, 0`;
+        }
+        else if (/^-?\d+$/.test(valor) || valor === 'true' || valor === 'false') {
+            const numVal = valor === 'true' ? '1' : valor === 'false' ? '0' : valor;
+            this.text += `\n    li ${registrador}, ${numVal}`;
+        }
+        else if (/^-?\d+\.\d+$/.test(valor)) {
+            // Ponto flutuante: armazenar em .data e carregar endereço.
+            // Operações FPU não são suportadas por esta implementação básica.
+            const floatLabel = `float_${this.gerarDigitoAleatorio()}`;
+            this.data += `    ${floatLabel}: .double ${valor}\n`;
+            this.text += `\n    la ${registrador}, ${floatLabel}`;
+        }
+        else {
+            this.text += `\n    la ${registrador}, ${valor}`;
+        }
+    }
+    // Implementação dos Construtos
+    traduzirAcessoIndiceVariavel(construto) {
+        var _a;
+        let nomeVar;
+        if (construto.entidadeChamada instanceof construtos_1.Variavel) {
+            nomeVar = (_a = construto.entidadeChamada.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar)
+            nomeVar = 'unknown';
+        const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
+        const reg = this.obterRegistrador();
+        this.text += `\n    la ${reg}, ${nomeVar}`;
+        this.emitirCarga('a0', indice);
+        this.text += `
+    slli a0, a0, 3          # multiplicar índice por 8 (palavra de 64 bits)
+    add ${reg}, ${reg}, a0
+    ld a0, 0(${reg})`;
+        this.liberarRegistrador(reg);
+        return 'a0';
+    }
+    traduzirConstrutoAcessoMetodo(construto) {
+        const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
+        return `${objeto}_${construto.nomeMetodo}`;
+    }
+    traduzirConstrutoAgrupamento(construto) {
+        return this.dicionarioConstrutos[construto.expressao.constructor.name](construto.expressao);
+    }
+    traduzirConstrutoAtribuicaoPorIndice(construto) {
+        var _a;
+        let nomeVar;
+        if (construto.objeto instanceof construtos_1.Variavel) {
+            nomeVar = (_a = construto.objeto.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar)
+            nomeVar = 'unknown';
+        const indice = this.dicionarioConstrutos[construto.indice.constructor.name](construto.indice);
+        const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        const reg = this.obterRegistrador();
+        this.text += `\n    la ${reg}, ${nomeVar}`;
+        this.emitirCarga('a1', indice);
+        this.text += `
+    slli a1, a1, 3          # multiplicar índice por 8
+    add ${reg}, ${reg}, a1`;
+        this.emitirCarga('a1', valor);
+        this.text += `\n    sd a1, 0(${reg})`;
+        this.liberarRegistrador(reg);
+    }
+    traduzirConstrutoAtribuir(construto) {
+        var _a;
+        let nomeVar;
+        if (construto.alvo instanceof construtos_1.Variavel) {
+            nomeVar = (_a = construto.alvo.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar)
+            return;
+        const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        if (!this.variaveis.has(nomeVar)) {
+            const varLabel = `var_${nomeVar}`;
+            this.bss += `    ${varLabel}: .space 8\n`;
+            this.variaveis.set(nomeVar, varLabel);
+        }
+        this.emitirCarga('a0', valor);
+        this.text += `
+    la a1, ${this.variaveis.get(nomeVar)}
+    sd a0, 0(a1)`;
+    }
+    traduzirConstrutoBinario(construto) {
+        const esquerda = this.dicionarioConstrutos[construto.esquerda.constructor.name](construto.esquerda);
+        const direita = this.dicionarioConstrutos[construto.direita.constructor.name](construto.direita);
+        const operador = construto.operador.lexema;
+        const reg = this.obterRegistrador();
+        // Carregar operando esquerdo em a0
+        if (esquerda !== 'a0') {
+            this.emitirCarga('a0', esquerda);
+        }
+        // Carregar operando direito no registrador scratch
+        this.emitirCarga(reg, direita);
+        switch (operador) {
+            case '+':
+                this.text += `\n    add a0, a0, ${reg}`;
+                break;
+            case '-':
+                this.text += `\n    sub a0, a0, ${reg}`;
+                break;
+            case '*':
+                this.text += `\n    mul a0, a0, ${reg}`;
+                break;
+            case '/':
+                this.text += `\n    div a0, a0, ${reg}`;
+                break;
+            case '%':
+                // `rem` é instrução única na extensão M (universal em rv64 Linux)
+                this.text += `\n    rem a0, a0, ${reg}`;
+                break;
+            case '<':
+                // slt: a0 = 1 se a0 < reg
+                this.text += `\n    slt a0, a0, ${reg}`;
+                break;
+            case '>':
+                // slt com operandos trocados: a0 = 1 se reg < a0, i.e., a0 > reg
+                this.text += `\n    slt a0, ${reg}, a0`;
+                break;
+            case '<=':
+                // NOT(a0 > reg) = NOT(reg < a0)
+                this.text += `\n    slt a0, ${reg}, a0\n    xori a0, a0, 1`;
+                break;
+            case '>=':
+                // NOT(a0 < reg)
+                this.text += `\n    slt a0, a0, ${reg}\n    xori a0, a0, 1`;
+                break;
+            case '==':
+            case '===':
+                // sub + seqz: a0 = 1 se a0 - reg == 0
+                this.text += `\n    sub a0, a0, ${reg}\n    seqz a0, a0`;
+                break;
+            case '!=':
+            case '!==':
+                // sub + snez: a0 = 1 se a0 - reg != 0
+                this.text += `\n    sub a0, a0, ${reg}\n    snez a0, a0`;
+                break;
+            default:
+                this.text += `\n    # Operador ${operador} não implementado`;
+        }
+        this.liberarRegistrador(reg);
+        return 'a0';
+    }
+    traduzirConstrutoChamada(construto) {
+        var _a;
+        let nomeFuncao = 'funcao';
+        if (construto.entidadeChamada instanceof construtos_1.Variavel) {
+            nomeFuncao = ((_a = construto.entidadeChamada.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
+        }
+        // Convenção RISC-V: a0-a7 para até 8 argumentos
+        const registrosArgs = ['a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7'];
+        construto.argumentos.forEach((arg, index) => {
+            if (index < registrosArgs.length) {
+                const valorArg = this.dicionarioConstrutos[arg.constructor.name](arg);
+                if (valorArg !== registrosArgs[index]) {
+                    this.emitirCarga(registrosArgs[index], valorArg);
+                }
+            }
+        });
+        this.text += `\n    call ${nomeFuncao}`;
+    }
+    traduzirConstrutoDefinirValor(construto) {
+        const objeto = this.dicionarioConstrutos[construto.objeto.constructor.name](construto.objeto);
+        const valor = this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+        this.emitirCarga('a0', valor);
+        this.text += `
+    la a1, ${objeto}
+    sd a0, 0(a1)`;
+    }
+    traduzirFuncaoConstruto(construto) {
+        const labelFuncao = `func_${this.gerarDigitoAleatorio()}`;
+        this.text += `
+
+${labelFuncao}:
+    addi sp, sp, -16
+    sd   ra, 8(sp)
+    sd   s0, 0(sp)
+    addi s0, sp, 16`;
+        if (construto.corpo && Array.isArray(construto.corpo)) {
+            construto.corpo.forEach((declaracao) => {
+                if (this.dicionarioDeclaracoes[declaracao.constructor.name]) {
+                    this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
+                }
+            });
+        }
+        this.text += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
+    ret`;
+    }
+    traduzirConstrutoLiteral(construto) {
+        if (typeof construto.valor === 'string') {
+            return this.criaStringLiteral(construto);
+        }
+        return String(construto.valor);
+    }
+    traduzirConstrutoLogico(construto) {
+        const esquerda = this.dicionarioConstrutos[construto.esquerda.constructor.name](construto.esquerda);
+        const direita = this.dicionarioConstrutos[construto.direita.constructor.name](construto.direita);
+        const operador = construto.operador.lexema;
+        const labelVerdadeiro = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        this.emitirCarga('a0', esquerda);
+        if (operador === 'e' || operador === '&&') {
+            this.text += `\n    beqz a0, ${labelFim}`;
+            this.emitirCarga('a0', direita);
+            this.text += `
+    beqz a0, ${labelFim}
+${labelVerdadeiro}:
+    li a0, 1
+${labelFim}:`;
+        }
+        else if (operador === 'ou' || operador === '||') {
+            this.text += `\n    bnez a0, ${labelVerdadeiro}`;
+            this.emitirCarga('a0', direita);
+            this.text += `
+    bnez a0, ${labelVerdadeiro}
+    li a0, 0
+    j ${labelFim}
+${labelVerdadeiro}:
+    li a0, 1
+${labelFim}:`;
+        }
+        return 'a0';
+    }
+    traduzirConstrutoTipoDe(construto) {
+        return this.dicionarioConstrutos[construto.valor.constructor.name](construto.valor);
+    }
+    traduzirConstrutoUnario(construto) {
+        const operando = this.dicionarioConstrutos[construto.operando.constructor.name](construto.operando);
+        const operador = construto.operador.lexema;
+        this.emitirCarga('a0', operando);
+        if (operador === '-') {
+            this.text += `\n    neg a0, a0`;
+        }
+        else if (operador === '!' || operador === 'nao') {
+            // seqz: a0 = 1 se a0 == 0, else 0
+            this.text += `\n    seqz a0, a0`;
+        }
+        return 'a0';
+    }
+    traduzirConstrutoVariavel(construto) {
+        var _a;
+        const nomeVar = (_a = construto.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (nomeVar && this.variaveis.has(nomeVar)) {
+            const varLabel = this.variaveis.get(nomeVar);
+            this.text += `
+    la a0, ${varLabel}
+    ld a0, 0(a0)`;
+            return 'a0';
+        }
+        return nomeVar || 'unknown';
+    }
+    traduzirConstrutoVetor(construto) {
+        const labelVetor = `vetor_${this.gerarDigitoAleatorio()}`;
+        // `elementos` filtra nós sintáticos (Separador, ComentarioComoConstruto)
+        const elementos = construto.elementos;
+        // Cada elemento ocupa 8 bytes em rv64
+        this.bss += `    ${labelVetor}: .space ${elementos.length * 8}\n`;
+        elementos.forEach((valor, index) => {
+            if (this.dicionarioConstrutos[valor.constructor.name]) {
+                const valorTraduzido = this.dicionarioConstrutos[valor.constructor.name](valor);
+                this.emitirCarga('a0', valorTraduzido);
+                this.text += `
+    la a1, ${labelVetor}
+    sd a0, ${index * 8}(a1)`;
+            }
+        });
+        return labelVetor;
+    }
+    // Implementação das Declarações
+    traduzirDeclaracaoBloco(declaracao) {
+        if (declaracao.declaracoes && Array.isArray(declaracao.declaracoes)) {
+            declaracao.declaracoes.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+    }
+    traduzirDeclaracaoEnquanto(declaracao) {
+        const labelInicio = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        this.text += `\n${labelInicio}:`;
+        const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+        if (condicao !== 'a0') {
+            this.emitirCarga('a0', condicao);
+        }
+        this.text += `\n    beqz a0, ${labelFim}`;
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        this.text += `
+    j ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoEscolha(declaracao) {
+        const labelFim = this.gerarLabel();
+        const valorEscolha = this.dicionarioConstrutos[declaracao.identificadorOuLiteral.constructor.name](declaracao.identificadorOuLiteral);
+        if (declaracao.caminhos && Array.isArray(declaracao.caminhos)) {
+            declaracao.caminhos.forEach((caminho) => {
+                const labelProximo = this.gerarLabel();
+                if (caminho.condicoes && caminho.condicoes[0]) {
+                    const valorCaso = this.dicionarioConstrutos[caminho.condicoes[0].constructor.name](caminho.condicoes[0]);
+                    this.emitirCarga('a0', valorEscolha);
+                    this.emitirCarga('a1', valorCaso);
+                    this.text += `\n    bne a0, a1, ${labelProximo}`;
+                    if (caminho.declaracoes && Array.isArray(caminho.declaracoes)) {
+                        caminho.declaracoes.forEach((decl) => {
+                            if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                                this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                            }
+                        });
+                    }
+                    this.text += `
+    j ${labelFim}
+${labelProximo}:`;
+                }
+            });
+        }
+        this.text += `\n${labelFim}:`;
+    }
+    traduzirDeclaracaoExpressao(declaracao) {
+        if (declaracao.expressao &&
+            this.dicionarioConstrutos[declaracao.expressao.constructor.name]) {
+            this.dicionarioConstrutos[declaracao.expressao.constructor.name](declaracao.expressao);
+        }
+    }
+    traduzirDeclaracaoFazer(declaracao) {
+        const labelInicio = this.gerarLabel();
+        this.text += `\n${labelInicio}:`;
+        if (declaracao.caminhoFazer && declaracao.caminhoFazer.declaracoes) {
+            declaracao.caminhoFazer.declaracoes.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+        if (declaracao.condicaoEnquanto) {
+            const condicao = this.dicionarioConstrutos[declaracao.condicaoEnquanto.constructor.name](declaracao.condicaoEnquanto);
+            if (condicao !== 'a0') {
+                this.emitirCarga('a0', condicao);
+            }
+            this.text += `\n    bnez a0, ${labelInicio}`;
+        }
+    }
+    traduzirDeclaracaoFalhar(declaracao) {
+        let mensagem = '"Erro"';
+        if (declaracao.explicacao &&
+            typeof declaracao.explicacao === 'object' &&
+            'constructor' in declaracao.explicacao) {
+            const explicacao = declaracao.explicacao;
+            if (explicacao.constructor && this.dicionarioConstrutos[explicacao.constructor.name]) {
+                mensagem = this.dicionarioConstrutos[explicacao.constructor.name](explicacao);
+            }
+        }
+        this.text += `
+    # Falhar com mensagem: ${mensagem}
+    li a0, 1
+    li a7, 93               # sys_exit
+    ecall`;
+    }
+    traduzirDeclaracaoFuncao(declaracao) {
+        var _a;
+        const nomeFuncao = ((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'funcao';
+        this.text += `
+
+${nomeFuncao}:
+    addi sp, sp, -16
+    sd   ra, 8(sp)
+    sd   s0, 0(sp)
+    addi s0, sp, 16`;
+        if (declaracao.funcao &&
+            declaracao.funcao.corpo &&
+            Array.isArray(declaracao.funcao.corpo)) {
+            declaracao.funcao.corpo.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+        this.text += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
+    ret`;
+    }
+    traduzirDeclaracaoImportar(declaracao) {
+        this.text += `\n    # Importar: ${declaracao.caminho || 'unknown'}`;
+    }
+    traduzirDeclaracaoLeia(declaracao) {
+        var _a;
+        let nomeVar;
+        if (declaracao.argumentos &&
+            declaracao.argumentos[0] &&
+            declaracao.argumentos[0] instanceof construtos_1.Variavel) {
+            nomeVar = (_a = declaracao.argumentos[0].simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        }
+        if (!nomeVar)
+            return;
+        if (!this.variaveis.has(nomeVar)) {
+            const varLabel = `var_${nomeVar}`;
+            this.bss += `    ${varLabel}: .space 256\n`;
+            this.variaveis.set(nomeVar, varLabel);
+        }
+        this.text += `
+    li a0, 0                # fd stdin
+    la a1, ${this.variaveis.get(nomeVar)}
+    li a2, 256
+    li a7, 63               # sys_read
+    ecall`;
+    }
+    traduzirDeclaracaoPara(declaracao) {
+        const labelInicio = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        if (declaracao.inicializador) {
+            const tipoInicializador = declaracao.inicializador.constructor.name;
+            if (this.dicionarioDeclaracoes[tipoInicializador]) {
+                this.dicionarioDeclaracoes[tipoInicializador](declaracao.inicializador);
+            }
+            else if (this.dicionarioConstrutos[tipoInicializador]) {
+                this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
+            }
+        }
+        this.text += `\n${labelInicio}:`;
+        if (declaracao.condicao) {
+            const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+            if (condicao !== 'a0') {
+                this.emitirCarga('a0', condicao);
+            }
+            this.text += `\n    beqz a0, ${labelFim}`;
+        }
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        if (declaracao.incrementar) {
+            if (this.dicionarioConstrutos[declaracao.incrementar.constructor.name]) {
+                this.dicionarioConstrutos[declaracao.incrementar.constructor.name](declaracao.incrementar);
+            }
+        }
+        this.text += `
+    j ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoParaCada(declaracao) {
+        const labelInicio = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        const vetor = declaracao.vetorOuDicionario;
+        let tamanhoVetor = 0;
+        if (vetor instanceof construtos_1.Vetor) {
+            tamanhoVetor = vetor.tamanho || 0;
+        }
+        // t0: contador; t1: limite (caller-saved, seguros aqui)
+        this.text += `
+    li t0, 0                # contador
+    li t1, ${tamanhoVetor}
+${labelInicio}:
+    bge t0, t1, ${labelFim}`;
+        if (this.dicionarioDeclaracoes[declaracao.corpo.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.corpo.constructor.name](declaracao.corpo);
+        }
+        this.text += `
+    addi t0, t0, 1
+    j ${labelInicio}
+${labelFim}:`;
+    }
+    traduzirDeclaracaoRetorna(declaracao) {
+        if (declaracao.valor) {
+            const valor = this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
+            this.emitirCarga('a0', valor);
+        }
+        this.text += `
+    ld   ra, 8(sp)
+    ld   s0, 0(sp)
+    addi sp, sp, 16
+    ret`;
+    }
+    traduzirDeclaracaoSe(declaracao) {
+        const labelSenao = this.gerarLabel();
+        const labelFim = this.gerarLabel();
+        const condicao = this.dicionarioConstrutos[declaracao.condicao.constructor.name](declaracao.condicao);
+        if (condicao !== 'a0') {
+            this.emitirCarga('a0', condicao);
+        }
+        this.text += `\n    beqz a0, ${labelSenao}`;
+        if (this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.caminhoEntao.constructor.name](declaracao.caminhoEntao);
+        }
+        this.text += `
+    j ${labelFim}
+${labelSenao}:`;
+        if (declaracao.caminhoSenao &&
+            this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name]) {
+            this.dicionarioDeclaracoes[declaracao.caminhoSenao.constructor.name](declaracao.caminhoSenao);
+        }
+        this.text += `\n${labelFim}:`;
+    }
+    traduzirDeclaracaoClasse(declaracao) {
+        var _a;
+        this.text += `\n    # Classe: ${((_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || 'unknown'}`;
+    }
+    traduzirDeclaracaoTente(declaracao) {
+        this.text += `\n    # Tente-pegue`;
+        if (declaracao.caminhoTente && Array.isArray(declaracao.caminhoTente)) {
+            declaracao.caminhoTente.forEach((decl) => {
+                if (this.dicionarioDeclaracoes[decl.constructor.name]) {
+                    this.dicionarioDeclaracoes[decl.constructor.name](decl);
+                }
+            });
+        }
+    }
+    traduzirDeclaracaoConst(declaracao) {
+        var _a;
+        const nomeVar = (_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (!nomeVar)
+            return;
+        const valor = this.dicionarioConstrutos[declaracao.inicializador.constructor.name](declaracao.inicializador);
+        const varLabel = `const_${nomeVar}`;
+        this.data += `    ${varLabel}: .dword ${valor}\n`;
+        this.variaveis.set(nomeVar, varLabel);
+    }
+    traduzirDeclaracaoVar(declaracao) {
+        var _a;
+        const nomeVar = (_a = declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema;
+        if (!nomeVar)
+            return;
+        const varLabel = `var_${nomeVar}`;
+        this.bss += `    ${varLabel}: .space 8\n`;
+        this.variaveis.set(nomeVar, varLabel);
+        if (declaracao.inicializador && declaracao.inicializador.valor !== null) {
+            const tipoInicializador = declaracao.inicializador.constructor.name;
+            if (declaracao.inicializador instanceof construtos_1.Vetor) {
+                const labelVetor = this.traduzirConstrutoVetor(declaracao.inicializador);
+                this.variaveis.set(nomeVar, labelVetor);
+            }
+            else if (this.dicionarioConstrutos[tipoInicializador]) {
+                const valor = this.dicionarioConstrutos[tipoInicializador](declaracao.inicializador);
+                this.emitirCarga('a0', valor);
+                this.text += `
+    la a1, ${varLabel}
+    sd a0, 0(a1)`;
+            }
+        }
+    }
+    criaStringLiteral(literal) {
+        const varLiteral = `Delegua_${this.gerarDigitoAleatorio()}`;
+        this.data += `    ${varLiteral}: .asciz "${literal.valor}"\n`;
+        return varLiteral;
+    }
+    criaTamanhoNaMemoriaReferenteAVar(nomeStringLiteral) {
+        return `tam_${nomeStringLiteral}`;
+    }
+    traduzirDeclaracaoEscreva(declaracaoEscreva) {
+        let nomeStringLiteral = '';
+        let tamanhoString = '';
+        if (declaracaoEscreva.argumentos[0] instanceof construtos_1.Literal) {
+            nomeStringLiteral = this.criaStringLiteral(declaracaoEscreva.argumentos[0]);
+            const stringValue = declaracaoEscreva.argumentos[0].valor;
+            tamanhoString = String(stringValue.length);
+        }
+        // sys_write(fd=1, buf, count): a7=64, a0=fd, a1=buf, a2=count
+        this.text += `
+    la a1, ${nomeStringLiteral}
+    li a2, ${tamanhoString}
+    li a0, 1                # fd stdout
+    li a7, 64               # sys_write
+    ecall`;
+    }
+    saidaSistema() {
+        this.text += `
+    li a0, 0                # código de saída
+    li a7, 93               # sys_exit
+    ecall`;
+    }
+    traduzir(declaracoes) {
+        this.declaracoesDeClasses = declaracoes.filter((declaracao) => declaracao instanceof declaracoes_1.Classe);
+        for (const declaracao of declaracoes) {
+            if (this.dicionarioDeclaracoes[declaracao.constructor.name]) {
+                this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
+            }
+        }
+        this.saidaSistema();
+        return this.bss + '\n' + this.data + '\n' + this.text;
+    }
+}
+exports.TradutorAssemblyRISCV = TradutorAssemblyRISCV;
+//# sourceMappingURL=tradutor-assembly-risc-v.js.map