spliting compiler into backend and frontend

This commit is contained in:
Nilton Constantino
2026-01-23 13:34:48 +00:00
parent 80eb06b73a
commit b3a6d22e2f
25 changed files with 1219 additions and 2309 deletions
@@ -34,4 +34,35 @@ pub fn map_btn_name(btn_name: &str) -> anyhow::Result<u32> {
"select" => Ok(BTN_SELECT),
_ => Err(anyhow!("Unsupported button: {}. Expected one of: up, down, left, right, a, b, x, y, l, r, start, select.", btn_name)),
}
}
/// Translates a pad state name (e.g., "pressed") into the corresponding syscall name.
pub fn map_pad_state(state_name: &str) -> anyhow::Result<&'static str> {
match state_name {
"down" => Ok("input.getPad"),
"pressed" => Ok("input.getPadPressed"),
"released" => Ok("input.getPadReleased"),
"holdFrames" => Ok("input.getPadHold"),
_ => Err(anyhow!("Unsupported button state: {}. Expected one of: down, pressed, released, holdFrames.", state_name)),
}
}
/// Translates a touch property name (e.g., "x") into the corresponding syscall name.
pub fn map_touch_prop(prop_name: &str) -> anyhow::Result<&'static str> {
match prop_name {
"x" => Ok("touch.getX"),
"y" => Ok("touch.getY"),
_ => Err(anyhow!("Unsupported touch property: {}. Expected one of: x, y.", prop_name)),
}
}
/// Translates a touch button state name (e.g., "down") into the corresponding syscall name.
pub fn map_touch_button_state(state_name: &str) -> anyhow::Result<&'static str> {
match state_name {
"down" => Ok("touch.isDown"),
"pressed" => Ok("touch.isPressed"),
"released" => Ok("touch.isReleased"),
"holdFrames" => Ok("touch.getHold"),
_ => Err(anyhow!("Unsupported touch button state: {}. Expected one of: down, pressed, released, holdFrames.", state_name)),
}
}
@@ -4,6 +4,7 @@ pub mod validate;
pub mod to_ir;
pub mod ast_util;
pub mod input_map;
pub mod syscall_map;
use crate::common::diagnostics::DiagnosticBundle;
use crate::frontends::Frontend;
@@ -0,0 +1,56 @@
use prometeu_core::hardware::Syscall;
/// Maps a high-level function name to its corresponding Syscall ID in the Virtual Machine.
///
/// This logic resides in the TypeScript frontend because string name resolution
/// from the source code is dependent on the language and the provided SDK.
pub fn map_syscall(name: &str) -> Option<u32> {
// Check if the name corresponds to a standard syscall defined in the core firmware
from_name(name)
}
/// Converts a textual name (e.g., "gfx.fillRect") to the numeric ID of the syscall.
fn from_name(name: &str) -> Option<u32> {
let id = match name.to_lowercase().as_str() {
"system.hascart" | "system.has_cart" => Syscall::SystemHasCart,
"system.runcart" | "system.run_cart" => Syscall::SystemRunCart,
"gfx.clear" => Syscall::GfxClear,
"gfx.fillrect" | "gfx.draw_rect" => Syscall::GfxFillRect,
"gfx.drawline" | "gfx.draw_line" => Syscall::GfxDrawLine,
"gfx.drawcircle" | "gfx.draw_circle" => Syscall::GfxDrawCircle,
"gfx.drawdisc" | "gfx.draw_disc" => Syscall::GfxDrawDisc,
"gfx.drawsquare" | "gfx.draw_square" => Syscall::GfxDrawSquare,
"gfx.setsprite" | "gfx.set_sprite" => Syscall::GfxSetSprite,
"gfx.drawtext" | "gfx.draw_text" => Syscall::GfxDrawText,
"input.getpad" | "input.get_pad" => Syscall::InputGetPad,
"input.getpadpressed" | "input.get_pad_pressed" => Syscall::InputGetPadPressed,
"input.getpadreleased" | "input.get_pad_released" => Syscall::InputGetPadReleased,
"input.getpadhold" | "input.get_pad_hold" => Syscall::InputGetPadHold,
"touch.getx" | "touch.get_x" => Syscall::TouchGetX,
"touch.gety" | "touch.get_y" => Syscall::TouchGetY,
"touch.isdown" | "touch.is_down" => Syscall::TouchIsDown,
"touch.ispressed" | "touch.is_pressed" => Syscall::TouchIsPressed,
"touch.isreleased" | "touch.is_released" => Syscall::TouchIsReleased,
"touch.gethold" | "touch.get_hold" => Syscall::TouchGetHold,
"audio.playsample" | "audio.play_sample" => Syscall::AudioPlaySample,
"audio.play" => Syscall::AudioPlay,
"fs.open" => Syscall::FsOpen,
"fs.read" => Syscall::FsRead,
"fs.write" => Syscall::FsWrite,
"fs.close" => Syscall::FsClose,
"fs.listdir" | "fs.list_dir" => Syscall::FsListDir,
"fs.exists" => Syscall::FsExists,
"fs.delete" => Syscall::FsDelete,
"log.write" => Syscall::LogWrite,
"log.writetag" | "log.write_tag" => Syscall::LogWriteTag,
"asset.load" => Syscall::AssetLoad,
"asset.status" => Syscall::AssetStatus,
"asset.commit" => Syscall::AssetCommit,
"asset.cancel" => Syscall::AssetCancel,
"bank.info" => Syscall::BankInfo,
"bank.slotinfo" | "bank.slot_info" => Syscall::BankSlotInfo,
_ => return None,
};
Some(id as u32)
}
@@ -1,4 +1,4 @@
use crate::backend::syscall_registry as syscall_map;
use crate::frontends::ts::syscall_map;
use crate::common::spans::Span as IRSpan;
use crate::frontends::ts::ast_util;
use crate::frontends::ts::input_map;
@@ -42,17 +42,10 @@ impl<'a> Visit<'a> for LocalCounter {
}
/// Metadata for a symbol (variable or function) in the symbol table.
#[allow(dead_code)]
struct SymbolEntry {
name: String,
slot_index: u32,
scope_depth: usize,
is_const: bool,
is_initialized: bool,
// PC of the instruction where the symbol was declared/initialized.
// Useful for debug symbols and potentially for more advanced TDZ checks.
declared_at_pc: u32,
initialized_at_pc: u32,
}
/// The TS AST to Prometeu IR translator.
@@ -120,13 +113,9 @@ impl ToIR {
self.next_local += 1;
let entry = SymbolEntry {
name: name.clone(),
slot_index,
scope_depth: self.scope_depth,
is_const,
is_initialized,
declared_at_pc: 0, // Will be filled if needed
initialized_at_pc: 0,
};
current_scope.insert(name.clone(), entry);
@@ -615,52 +604,69 @@ impl ToIR {
// Function calls: resolve to Syscall or Call
Expression::CallExpression(call) => {
let name = ast_util::get_callee_name(&call.callee)?;
if let Some(syscall_id) = syscall_map::map_syscall(&name) {
if syscall_id == 0xFFFF_FFFF {
// Special case for Color.rgb(r, g, b)
// It's compiled to a sequence of bitwise operations for performance
if call.arguments.len() != 3 {
return Err(anyhow!("Color.rgb expects 3 arguments at {:?}", call.span));
}
// Argument 0: r (shift right 3, shift left 11)
if let Some(expr) = call.arguments[0].as_expression() {
self.compile_expr(expr)?;
self.emit_instr(InstrKind::PushInt(3), call.span);
self.emit_instr(InstrKind::Shr, call.span);
self.emit_instr(InstrKind::PushInt(11), call.span);
self.emit_instr(InstrKind::Shl, call.span);
}
// Argument 1: g (shift right 2, shift left 5)
if let Some(expr) = call.arguments[1].as_expression() {
self.compile_expr(expr)?;
self.emit_instr(InstrKind::PushInt(2), call.span);
self.emit_instr(InstrKind::Shr, call.span);
self.emit_instr(InstrKind::PushInt(5), call.span);
self.emit_instr(InstrKind::Shl, call.span);
}
self.emit_instr(InstrKind::BitOr, call.span);
// Argument 2: b (shift right 3)
if let Some(expr) = call.arguments[2].as_expression() {
self.compile_expr(expr)?;
self.emit_instr(InstrKind::PushInt(3), call.span);
self.emit_instr(InstrKind::Shr, call.span);
}
self.emit_instr(InstrKind::BitOr, call.span);
} else {
// Standard System Call
for arg in &call.arguments {
if let Some(expr) = arg.as_expression() {
self.compile_expr(expr)?;
}
}
self.emit_instr(InstrKind::Syscall(name), call.span);
let name_lower = name.to_lowercase();
if name_lower == "color.rgb" {
// Special case for Color.rgb(r, g, b)
// It's compiled to a sequence of bitwise operations for performance
if call.arguments.len() != 3 {
return Err(anyhow!("Color.rgb expects 3 arguments at {:?}", call.span));
}
// Argument 0: r (shift right 3, shift left 11)
if let Some(expr) = call.arguments[0].as_expression() {
self.compile_expr(expr)?;
self.emit_instr(InstrKind::PushInt(3), call.span);
self.emit_instr(InstrKind::Shr, call.span);
self.emit_instr(InstrKind::PushInt(11), call.span);
self.emit_instr(InstrKind::Shl, call.span);
}
// Argument 1: g (shift right 2, shift left 5)
if let Some(expr) = call.arguments[1].as_expression() {
self.compile_expr(expr)?;
self.emit_instr(InstrKind::PushInt(2), call.span);
self.emit_instr(InstrKind::Shr, call.span);
self.emit_instr(InstrKind::PushInt(5), call.span);
self.emit_instr(InstrKind::Shl, call.span);
}
self.emit_instr(InstrKind::BitOr, call.span);
// Argument 2: b (shift right 3)
if let Some(expr) = call.arguments[2].as_expression() {
self.compile_expr(expr)?;
self.emit_instr(InstrKind::PushInt(3), call.span);
self.emit_instr(InstrKind::Shr, call.span);
}
self.emit_instr(InstrKind::BitOr, call.span);
} else if name_lower.starts_with("input.btn") || name_lower.starts_with("pinput.btn") {
// Special case for legacy Input.btnX() calls
// They map to input.getPad(BTN_X)
let btn_name = if name_lower.starts_with("pinput.btn") {
&name[10..]
} else {
&name[9..]
};
// Strip parentheses if any (though get_callee_name should handle just the callee)
let btn_name = btn_name.strip_suffix("()").unwrap_or(btn_name);
let btn_id = input_map::map_btn_name(btn_name)?;
self.emit_instr(InstrKind::PushInt(btn_id as i64), call.span);
let pad_id = syscall_map::map_syscall("input.getPad").ok_or_else(|| anyhow!("input.getPad syscall not found"))?;
self.emit_instr(InstrKind::Syscall(pad_id), call.span);
} else if let Some(syscall_id) = syscall_map::map_syscall(&name) {
// Standard System Call
for arg in &call.arguments {
if let Some(expr) = arg.as_expression() {
self.compile_expr(expr)?;
}
}
self.emit_instr(InstrKind::Syscall(syscall_id), call.span);
} else {
// Local function call (to a function defined in the project)
for arg in &call.arguments {
@@ -689,7 +695,7 @@ impl ToIR {
"color.orange" => self.emit_instr(InstrKind::PushInt(Color::ORANGE.raw() as i64), member.span),
"color.indigo" => self.emit_instr(InstrKind::PushInt(Color::INDIGO.raw() as i64), member.span),
"color.magenta" => self.emit_instr(InstrKind::PushInt(Color::MAGENTA.raw() as i64), member.span),
"color.colorkey" | "color.color_key" => self.emit_instr(InstrKind::PushInt(Color::COLOR_KEY.raw() as i64), member.span),
"color.colorKey" | "color.color_key" => self.emit_instr(InstrKind::PushInt(Color::COLOR_KEY.raw() as i64), member.span),
_ => return Err(anyhow!("Unsupported color constant: {} at {:?}", full_name, member.span)),
}
} else if full_name.to_lowercase().starts_with("pad.") {
@@ -699,15 +705,10 @@ impl ToIR {
let btn_name = parts[1];
let state_name = parts[2];
let btn_id = input_map::map_btn_name(btn_name)?;
let syscall_name = match state_name {
"down" => "InputGetPad",
"pressed" => "InputGetPadPressed",
"released" => "InputGetPadReleased",
"holdFrames" => "InputGetPadHold",
_ => return Err(anyhow!("Unsupported button state: {} at {:?}", state_name, member.span)),
};
let syscall_name = input_map::map_pad_state(state_name)?;
let syscall_id = syscall_map::map_syscall(syscall_name).unwrap();
self.emit_instr(InstrKind::PushInt(btn_id as i64), member.span);
self.emit_instr(InstrKind::Syscall(syscall_name.to_string()), member.span);
self.emit_instr(InstrKind::Syscall(syscall_id), member.span);
} else {
return Err(anyhow!("Partial Pad access not supported: {} at {:?}", full_name, member.span));
}
@@ -717,23 +718,15 @@ impl ToIR {
match parts.len() {
2 => {
let prop = parts[1];
let syscall_name = match prop {
"x" => "TouchGetX",
"y" => "TouchGetY",
_ => return Err(anyhow!("Unsupported touch property: {} at {:?}", prop, member.span)),
};
self.emit_instr(InstrKind::Syscall(syscall_name.to_string()), member.span);
let syscall_name = input_map::map_touch_prop(prop)?;
let syscall_id = syscall_map::map_syscall(syscall_name).unwrap();
self.emit_instr(InstrKind::Syscall(syscall_id), member.span);
}
3 if parts[1] == "button" => {
let state_name = parts[2];
let syscall_name = match state_name {
"down" => "TouchIsDown",
"pressed" => "TouchIsPressed",
"released" => "TouchIsReleased",
"holdFrames" => "TouchGetHold",
_ => return Err(anyhow!("Unsupported touch button state: {} at {:?}", state_name, member.span)),
};
self.emit_instr(InstrKind::Syscall(syscall_name.to_string()), member.span);
let syscall_name = input_map::map_touch_button_state(state_name)?;
let syscall_id = syscall_map::map_syscall(syscall_name).unwrap();
self.emit_instr(InstrKind::Syscall(syscall_id), member.span);
}
_ => return Err(anyhow!("Unsupported touch access: {} at {:?}", full_name, member.span)),
}
@@ -1,4 +1,4 @@
use crate::backend::syscall_registry as syscall_map;
use crate::frontends::ts::syscall_map;
use crate::frontends::ts::ast_util;
use anyhow::{anyhow, Result};
use oxc_ast::ast::*;
@@ -104,7 +104,10 @@ impl<'a> Visit<'a> for Validator {
fn visit_call_expression(&mut self, expr: &CallExpression<'a>) {
if let Ok(name) = ast_util::get_callee_name(&expr.callee) {
if syscall_map::map_syscall(&name).is_none() && !self.local_functions.contains(&name) {
let name_lower = name.to_lowercase();
let is_intrinsic = name_lower == "color.rgb" || name_lower.starts_with("input.btn") || name_lower.starts_with("pinput.btn");
if !is_intrinsic && syscall_map::map_syscall(&name).is_none() && !self.local_functions.contains(&name) {
self.errors.push(format!("Unsupported function call: {} at {:?}", name, expr.span));
}
} else {