oxentescript/src/transpiler.js

🌴 A Linguagem de Programação dos Baianos com Tokens Coloquiais Brasileiros + Syntax Highlighting Colorido!

import fs from 'fs';
import path from 'path';

/**
 * 🌴 OxenteScript Transpiler
 * Converte código OxenteScript para JavaScript
 */
export class OxenteTranspiler {
    constructor() {
        // Mapeamento das palavras-chave baianas para JavaScript
        this.keywords = {
            // Declarações
            'bora': 'let',
            'massa': 'const',
            
            // Condicionais
            'sefizer': 'if',
            'sefor': 'else',
            'senaose': 'else if',
            
            // Loops
            'porfavor': 'for',
            'enquantoquetiver': 'while',
            
            // Funções
            'acao': 'function',
            'devolve': 'return',
            
            // Console/Print
            'falaai': 'console.log',
            'laele': 'console.log', // Expressão baiana especial!
            
            // Tratamento de erros
            'tenta': 'try',
            'pegouproblema': 'catch',
            
            // Comparadores
            'igualzin': '===',
            'diferentao': '!==',
            'maiorzin': '>',
            'menorzin': '<',
            'maiorigual': '>=',
            'menorigual': '<=',
            
            // Valores
            'verdade': 'true',
            'mentira': 'false',
            'nada': 'null',
            'oxe': 'undefined'
        };
    }

    /**
     * Transpila código OxenteScript para JavaScript
     * @param {string} oxenteCode - Código em OxenteScript
     * @returns {string} - Código JavaScript equivalente
     */
    transpile(oxenteCode) {
        let jsCode = oxenteCode;
        
        // 1. Preservar strings literais temporariamente
        const strings = [];
        jsCode = jsCode.replace(/(["'`])((?:(?!\1)[^\\]|\\.)*)(\1)/g, (match) => {
            const index = strings.length;
            strings.push(match);
            return `__STRING_${index}__`;
        });
        
        // 2. Converter comentários baianos para JavaScript
        jsCode = jsCode.replace(/#(.*)$/gm, '// $1');
        
        // 3. Tratar expressões especiais baianas
        // "laele" pode ser usado sozinho como exclamação
        jsCode = jsCode.replace(/\blaele\s*;/g, 'console.log("Lá ele! 🌴");');
        jsCode = jsCode.replace(/\blaele\s+([^;]+);/g, 'console.log("Lá ele!", $1);');
        
        // 4. Converter estruturas condicionais específicas
        jsCode = jsCode.replace(/sefizer\s+([^{]+)\s*{/g, 'if ($1) {');
        jsCode = jsCode.replace(/}\s*senaose\s+([^{]+)\s*{/g, '} else if ($1) {');
        jsCode = jsCode.replace(/}\s*sefor\s*{/g, '} else {');
        
        // 5. Converter loops
        jsCode = jsCode.replace(/porfavor\s+([^{]+)\s*{/g, 'for ($1) {');
        jsCode = jsCode.replace(/enquantoquetiver\s+([^{]+)\s*{/g, 'while ($1) {');
        
        // 6. Converter declarações de função
        jsCode = jsCode.replace(/acao\s+(\w+)\s*\(([^)]*)\)\s*{/g, 'function $1($2) {');
        
        // 7. Converter outras palavras-chave
        Object.entries(this.keywords).forEach(([oxente, js]) => {
            const regex = new RegExp(`\\b${oxente}\\b`, 'g');
            jsCode = jsCode.replace(regex, js);
        });
        
        // 8. Restaurar strings literais
        strings.forEach((str, index) => {
            jsCode = jsCode.replace(new RegExp(`__STRING_${index}__`, 'g'), str);
        });
        
        // 9. Adicionar header com informações da linguagem
        const header = `// Código transpilado de OxenteScript para JavaScript\n// Oxente, que massa! Lá ele! 🌴\n\n`;
        
        return header + jsCode;
    }

    /**
     * Transpila um arquivo .oxe para JavaScript
     * @param {string} inputFile - Caminho do arquivo .oxe
     * @param {string} outputFile - Caminho do arquivo .js de saída (opcional)
     */
    transpileFile(inputFile, outputFile = null) {
        try {
            // Ler arquivo OxenteScript
            const oxenteCode = fs.readFileSync(inputFile, 'utf8');
            
            // Transpilar código
            const jsCode = this.transpile(oxenteCode);
            
            // Determinar arquivo de saída
            if (!outputFile) {
                const parsedPath = path.parse(inputFile);
                outputFile = path.join(parsedPath.dir, parsedPath.name + '.js');
            }
            
            // Escrever arquivo JavaScript
            fs.writeFileSync(outputFile, jsCode, 'utf8');
            
            console.log(`🌴 Oxente! Arquivo transpilado com sucesso:`);
            console.log(`   ${inputFile} → ${outputFile}`);
            
            return outputFile;
        } catch (error) {
            console.error('❌ Ôxe, deu ruim na transpilação:', error.message);
            throw error;
        }
    }

    /**
     * Executa um arquivo OxenteScript diretamente
     * @param {string} inputFile - Caminho do arquivo .oxe
     */
    async runFile(inputFile) {
        try {
            // Transpilar para arquivo temporário
            const tempFile = path.join(path.dirname(inputFile), 'temp_' + Date.now() + '.js');
            this.transpileFile(inputFile, tempFile);
            
            // Executar arquivo JavaScript
            const { exec } = await import('child_process');
            const { promisify } = await import('util');
            const execAsync = promisify(exec);
            
            console.log('\n🌴 Executando OxenteScript...\n');
            const { stdout, stderr } = await execAsync(`node ${tempFile}`);
            
            if (stdout) console.log(stdout);
            if (stderr) console.error(stderr);
            
            // Limpar arquivo temporário
            fs.unlinkSync(tempFile);
            
        } catch (error) {
            console.error('❌ Ôxe, deu problema na execução:', error.message);
            throw error;
        }
    }
}

// Exportar instância singleton
export const transpiler = new OxenteTranspiler();

// Se executado diretamente
if (import.meta.url === `file://${process.argv[1]}`) {
    const inputFile = process.argv[2];
    
    if (!inputFile) {
        console.log('🌴 OxenteScript Transpiler');
        console.log('Uso: node transpiler.js <arquivo.oxe>');
        process.exit(1);
    }
    
    try {
        transpiler.transpileFile(inputFile);
    } catch (error) {
        process.exit(1);
    }
}