many fixes on compiler

This commit is contained in:
Nilton Constantino
2026-01-21 07:48:06 +00:00
parent 1b091e6ce8
commit 11d9d31c2f
9 changed files with 266 additions and 94 deletions
@@ -2,21 +2,25 @@ use oxc_ast::ast::*;
use anyhow::{Result, anyhow};
pub fn get_callee_name(expr: &Expression) -> Result<String> {
get_member_expr_name(expr)
}
pub fn get_member_expr_name(expr: &Expression) -> Result<String> {
match expr {
Expression::Identifier(ident) => Ok(ident.name.to_string()),
Expression::Identifier(ident) => {
let name = ident.name.to_string();
// Remove prefix 'P' if it's followed by an uppercase letter (e.g., PGfx -> Gfx)
if name.len() > 1 && name.starts_with('P') && name.chars().nth(1).unwrap().is_uppercase() {
Ok(name[1..].to_string())
} else {
Ok(name)
}
}
Expression::StaticMemberExpression(member) => {
let obj = get_callee_name_from_member_obj(&member.object)?;
let obj = get_member_expr_name(&member.object)?;
let prop = member.property.name.to_string();
Ok(format!("{}.{}", obj, prop))
}
_ => Err(anyhow!("Unsupported callee expression")),
}
}
pub fn get_callee_name_from_member_obj(expr: &Expression) -> Result<String> {
if let Expression::Identifier(ident) = expr {
Ok(ident.name.to_string())
} else {
Err(anyhow!("Unsupported member object expression"))
_ => Err(anyhow!("Unsupported expression")),
}
}
+104 -21
View File
@@ -3,9 +3,11 @@ use oxc_ast::ast::*;
use oxc_span::{Span, GetSpan};
use prometeu_bytecode::opcode::OpCode;
use prometeu_bytecode::asm::{Asm, Operand, assemble};
use prometeu_bytecode::pbc::{ConstantPoolEntry, PbcFile, write_pbc};
use crate::compiler::Symbol;
use crate::syscall_map;
use crate::codegen::ast_util;
use prometeu_core::prometeu_os::Syscall;
use std::collections::HashMap;
use prometeu_bytecode::asm;
@@ -15,6 +17,7 @@ pub struct Codegen {
pub symbols: Vec<Symbol>,
instructions: Vec<(Asm, bool)>, // (Asm, has_symbol)
locals: HashMap<String, u32>,
constant_pool: Vec<ConstantPoolEntry>,
next_local: u32,
label_count: u32,
}
@@ -27,11 +30,22 @@ impl Codegen {
symbols: Vec::new(),
instructions: Vec::new(),
locals: HashMap::new(),
constant_pool: vec![ConstantPoolEntry::Null], // Index 0 is always Null
next_local: 0,
label_count: 0,
}
}
fn add_constant(&mut self, entry: ConstantPoolEntry) -> u32 {
if let Some(pos) = self.constant_pool.iter().position(|e| e == &entry) {
pos as u32
} else {
let pos = self.constant_pool.len();
self.constant_pool.push(entry);
pos as u32
}
}
pub fn compile_program(&mut self, program: &Program) -> Result<Vec<u8>> {
// Find tick function
let mut tick_fn = None;
@@ -63,12 +77,17 @@ impl Codegen {
self.emit_op(OpCode::Ret, vec![], Span::default());
let asm_vec: Vec<Asm> = self.instructions.iter().map(|(a, _)| a.clone()).collect();
let rom = assemble(&asm_vec).map_err(|e| anyhow!("Assemble error: {}", e))?;
let bytecode = assemble(&asm_vec).map_err(|e| anyhow!("Assemble error: {}", e))?;
// Finalize symbols (associate PC)
self.finalize_symbols();
Ok(rom)
let pbc = PbcFile {
cp: self.constant_pool.clone(),
rom: bytecode,
};
write_pbc(&pbc).map_err(|e| anyhow!("PBC Write error: {}", e))
}
fn compile_function(&mut self, f: &Function) -> Result<()> {
@@ -150,6 +169,13 @@ impl Codegen {
Expression::BooleanLiteral(b) => {
self.emit_op(OpCode::PushBool, vec![Operand::Bool(b.value)], b.span);
}
Expression::StringLiteral(s) => {
let idx = self.add_constant(ConstantPoolEntry::String(s.value.to_string()));
self.emit_op(OpCode::PushConst, vec![Operand::U32(idx)], s.span);
}
Expression::NullLiteral(n) => {
self.emit_op(OpCode::PushConst, vec![Operand::U32(0)], n.span);
}
Expression::Identifier(ident) => {
let name = ident.name.to_string();
if let Some(&id) = self.locals.get(&name) {
@@ -251,12 +277,6 @@ impl Codegen {
self.emit_op(OpCode::BitOr, vec![], call.span);
} else if name == "input.btnA" || name == "Input.btnA" {
self.emit_op(OpCode::PushI32, vec![Operand::I32(syscall_map::BTN_A as i32)], call.span);
self.emit_op(OpCode::Syscall, vec![Operand::U32(syscall_id)], call.span);
} else if name == "input.btnB" || name == "Input.btnB" {
self.emit_op(OpCode::PushI32, vec![Operand::I32(syscall_map::BTN_B as i32)], call.span);
self.emit_op(OpCode::Syscall, vec![Operand::U32(syscall_id)], call.span);
} else {
for arg in &call.arguments {
if let Some(expr) = arg.as_expression() {
@@ -270,20 +290,65 @@ impl Codegen {
}
}
Expression::StaticMemberExpression(member) => {
let obj = ast_util::get_callee_name_from_member_obj(&member.object)?;
let prop = member.property.name.to_string();
let full_name = format!("{}.{}", obj, prop);
let full_name = ast_util::get_member_expr_name(expr)?;
match full_name.as_str() {
"Color.black" | "color.black" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0x0000)], member.span),
"Color.white" | "color.white" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0xffff)], member.span),
"Color.red" | "color.red" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0xf800)], member.span),
"Color.green" | "color.green" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0x07e0)], member.span),
"Color.blue" | "color.blue" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0x001f)], member.span),
"Color.yellow" | "color.yellow" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0xffe0)], member.span),
"Color.cyan" | "color.cyan" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0x07ff)], member.span),
"Color.magenta" | "color.magenta" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0xf81f)], member.span),
_ => return Err(anyhow!("Member expression outside call not supported: {} at {:?}", full_name, member.span)),
if full_name.to_lowercase().starts_with("color.") {
match full_name.to_lowercase().as_str() {
"color.black" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0x0000)], member.span),
"color.white" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0xffff)], member.span),
"color.red" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0xf800)], member.span),
"color.green" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0x07e0)], member.span),
"color.blue" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0x001f)], member.span),
"color.yellow" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0xffe0)], member.span),
"color.cyan" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0x07ff)], member.span),
"color.magenta" => self.emit_op(OpCode::PushI32, vec![Operand::I32(0xf81f)], member.span),
_ => return Err(anyhow!("Unsupported color constant: {} at {:?}", full_name, member.span)),
}
} else if full_name.to_lowercase().starts_with("pad.") {
let parts: Vec<&str> = full_name.split('.').collect();
if parts.len() == 3 {
let btn_name = parts[1];
let state_name = parts[2];
let btn_id = self.map_btn_name(btn_name)?;
let syscall_id = match state_name {
"down" => Syscall::InputGetPad as u32,
"pressed" => Syscall::InputGetPadPressed as u32,
"released" => Syscall::InputGetPadReleased as u32,
"holdFrames" => Syscall::InputGetPadHold as u32,
_ => return Err(anyhow!("Unsupported button state: {} at {:?}", state_name, member.span)),
};
self.emit_op(OpCode::PushI32, vec![Operand::I32(btn_id as i32)], member.span);
self.emit_op(OpCode::Syscall, vec![Operand::U32(syscall_id)], member.span);
} else {
return Err(anyhow!("Partial Pad access not supported: {} at {:?}", full_name, member.span));
}
} else if full_name.to_lowercase().starts_with("touch.") {
let parts: Vec<&str> = full_name.split('.').collect();
match parts.len() {
2 => {
let prop = parts[1];
let syscall_id = match prop {
"x" => Syscall::TouchGetX as u32,
"y" => Syscall::TouchGetY as u32,
_ => return Err(anyhow!("Unsupported touch property: {} at {:?}", prop, member.span)),
};
self.emit_op(OpCode::Syscall, vec![Operand::U32(syscall_id)], member.span);
}
3 if parts[1] == "button" => {
let state_name = parts[2];
let syscall_id = match state_name {
"down" => Syscall::TouchIsDown as u32,
"pressed" => Syscall::TouchIsPressed as u32,
"released" => Syscall::TouchIsReleased as u32,
"holdFrames" => Syscall::TouchGetHold as u32,
_ => return Err(anyhow!("Unsupported touch button state: {} at {:?}", state_name, member.span)),
};
self.emit_op(OpCode::Syscall, vec![Operand::U32(syscall_id)], member.span);
}
_ => return Err(anyhow!("Unsupported touch access: {} at {:?}", full_name, member.span)),
}
} else {
return Err(anyhow!("Member expression outside call not supported: {} at {:?}", full_name, member.span));
}
}
_ => return Err(anyhow!("Unsupported expression type at {:?}", expr.span())),
@@ -291,6 +356,24 @@ impl Codegen {
Ok(())
}
fn map_btn_name(&self, btn_name: &str) -> Result<u32> {
match btn_name.to_lowercase().as_str() {
"up" => Ok(syscall_map::BTN_UP),
"down" => Ok(syscall_map::BTN_DOWN),
"left" => Ok(syscall_map::BTN_LEFT),
"right" => Ok(syscall_map::BTN_RIGHT),
"a" => Ok(syscall_map::BTN_A),
"b" => Ok(syscall_map::BTN_B),
"x" => Ok(syscall_map::BTN_X),
"y" => Ok(syscall_map::BTN_Y),
"l" => Ok(syscall_map::BTN_L),
"r" => Ok(syscall_map::BTN_R),
"start" => Ok(syscall_map::BTN_START),
"select" => Ok(syscall_map::BTN_SELECT),
_ => Err(anyhow!("Unsupported button: {}", btn_name)),
}
}
fn new_label(&mut self, prefix: &str) -> String {
let label = format!("{}_{}", prefix, self.label_count);
self.label_count += 1;
@@ -65,6 +65,8 @@ impl<'a> Visit<'a> for Validator {
match expr {
Expression::NumericLiteral(_) |
Expression::BooleanLiteral(_) |
Expression::StringLiteral(_) |
Expression::NullLiteral(_) |
Expression::Identifier(_) |
Expression::AssignmentExpression(_) |
Expression::BinaryExpression(_) |
+9 -1
View File
@@ -34,7 +34,15 @@ impl CompilationUnit {
if emit_disasm {
let disasm_path = out.with_extension("disasm.txt");
let instructions = disasm(&self.rom).map_err(|e| anyhow::anyhow!("Disassembly failed: {}", e))?;
// Try to parse as PBC, if fails use raw
let rom_to_disasm = if let Ok(pbc) = prometeu_bytecode::pbc::parse_pbc(&self.rom) {
pbc.rom
} else {
self.rom.clone()
};
let instructions = disasm(&rom_to_disasm).map_err(|e| anyhow::anyhow!("Disassembly failed: {}", e))?;
let mut disasm_text = String::new();
for instr in instructions {
@@ -21,7 +21,6 @@ pub fn map_syscall(name: &str) -> Option<u32> {
// Fallback para nomes especiais do compilador
match name {
"input.btnA" | "input.btnB" | "Input.btnA" | "Input.btnB" => Some(Syscall::InputGetPad as u32),
"Color.rgb" | "color.rgb" => Some(0xFFFF_FFFF), // ID especial para Color.rgb (não é um syscall real)
_ => None,
}