ITStudio_OUC/OxideJS
Archived
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(compiler): remove statement jump count helpers

Browse Source
This commit is contained in:
爱特每羊队
2026-08-05 01:17:22 +08:00
parent faa326c039
commit 4a2bf09f78
9 changed files with 28 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/oxide_compiler/src/compiler.rs
+12 -6
View File
@@ -331,6 +331,17 @@ impl CompileCtx {
});
}
pub(crate) fn emit_try_finally_begin_labeled(&mut self, label: Label) {
let pc = self.bytecode.len();
self.emit(opcode::encode_try_finally_begin(0));
self.fixups.push(JumpFixup {
pc,
label,
opcode: OpCode::TRY_FINALLY_BEGIN,
rd: 0,
});
}
pub(crate) fn count_word(&mut self) {
self.projected_pc += 1;
}
@@ -481,6 +492,7 @@ impl CompileCtx {
OpCode::JMP_IF_TRUE => opcode::encode_jmp_if_true(fixup.rd, offset),
OpCode::JMP_IF_NULLISH => opcode::encode_jmp_if_nullish(fixup.rd, offset),
OpCode::TRY_BEGIN => opcode::encode_try_begin(offset),
OpCode::TRY_FINALLY_BEGIN => opcode::encode_try_finally_begin(offset),
_ => return Err(format!("Unsupported fixup opcode {:?}", fixup.opcode)),
};
}
@@ -1275,17 +1287,11 @@ impl Compiler {
pub(crate) fn count_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) {
match stmt {
Statement::BreakStatement(_) | Statement::ContinueStatement(_) | Statement::LabeledStatement(_) => {
self.count_basic(stmt, ctx)
}
Statement::IfStatement(_) => self.count_control_domain(stmt, ctx),
Statement::WhileStatement(_)
| Statement::DoWhileStatement(_)
| Statement::ForStatement(_)
| Statement::ForInStatement(_)
| Statement::ForOfStatement(_) => self.count_iteration_domain(stmt, ctx),
Statement::SwitchStatement(_) => self.count_switch_domain(stmt, ctx),
Statement::TryStatement(_) => self.count_exception_domain(stmt, ctx),
_ => {}
}
}
crates/oxide_compiler/src/stmt/basic/break_continue.rs
-8
View File
@@ -1,14 +1,6 @@
use crate::compiler::{CompileCtx, Compiler};
impl Compiler {
pub(super) fn count_break_statement(&self, ctx: &mut CompileCtx) {
ctx.projected_pc += 1;
}
pub(super) fn count_continue_statement(&self, ctx: &mut CompileCtx) {
ctx.projected_pc += 1;
}
pub(crate) fn emit_break_statement(
&self, stmt: &oxide_parser::BreakStatement, ctx: &mut CompileCtx,
) -> Result<Option<u8>, String> {
crates/oxide_compiler/src/stmt/basic/labeled.rs
-18
View File
@@ -2,24 +2,6 @@ use crate::compiler::{CompileCtx, Compiler, Label};
use oxide_parser::Statement;
impl Compiler {
pub(super) fn count_labeled_statement(&self, stmt: &oxide_parser::LabeledStatement<'_>, ctx: &mut CompileCtx) {
let body_is_loop = matches!(
stmt.body,
Statement::WhileStatement(_)
| Statement::DoWhileStatement(_)
| Statement::ForStatement(_)
| Statement::ForInStatement(_)
| Statement::ForOfStatement(_)
);
if body_is_loop {
self.count_statement(&stmt.body, ctx);
} else {
let id = ctx.next_label_id();
self.count_statement(&stmt.body, ctx);
ctx.labels.label_map.insert(Label::LabeledEnd(id), ctx.projected_pc);
}
}
fn is_iteration_statement(stmt: &Statement) -> bool {
matches!(
stmt,
crates/oxide_compiler/src/stmt/basic/mod.rs
-9
View File
@@ -15,13 +15,4 @@ impl Compiler {
_ => Ok(None),
}
}
pub(crate) fn count_basic(&self, stmt: &Statement, ctx: &mut CompileCtx) {
match stmt {
Statement::BreakStatement(_) => self.count_break_statement(ctx),
Statement::ContinueStatement(_) => self.count_continue_statement(ctx),
Statement::LabeledStatement(ls) => self.count_labeled_statement(ls, ctx),
_ => {}
}
}
}
crates/oxide_compiler/src/stmt/control.rs
-27
View File
@@ -4,27 +4,6 @@ use oxide_bytecode::opcode::{self, OpCode};
use oxide_parser::Statement;
impl Compiler {
fn count_if_statement(&self, stmt: &oxide_parser::IfStatement<'_>, ctx: &mut CompileCtx) {
let id = ctx.next_label_id();
let else_label = Label::IfElse(id);
let end_label = Label::IfEnd(id);
self.count_expression(&stmt.test, ctx);
ctx.projected_pc += 1;
self.count_statement(&stmt.consequent, ctx);
ctx.alloc_reg();
ctx.projected_pc += 1;
if stmt.alternate.is_some() {
ctx.projected_pc += 1;
}
ctx.labels.label_map.insert(else_label, ctx.projected_pc);
if let Some(alt_stmt) = &stmt.alternate {
self.count_statement(alt_stmt, ctx);
ctx.projected_pc += 1;
}
ctx.labels.label_map.insert(end_label, ctx.projected_pc);
}
fn emit_if_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
let Statement::IfStatement(ifs) = stmt else {
return Ok(None);
@@ -66,12 +45,6 @@ impl Compiler {
Ok(Some(result_reg))
}
pub(crate) fn count_control_domain(&self, stmt: &Statement, ctx: &mut CompileCtx) {
if let Statement::IfStatement(ifs) = stmt {
self.count_if_statement(ifs, ctx);
}
}
pub(crate) fn emit_control_domain(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
match stmt {
Statement::IfStatement(_) => self.emit_if_statement(stmt, ctx),
crates/oxide_compiler/src/stmt/exception/mod.rs
-7
View File
@@ -5,13 +5,6 @@ mod throw;
mod try_catch;
impl Compiler {
pub(crate) fn count_exception_domain(&self, stmt: &Statement, ctx: &mut CompileCtx) {
match stmt {
Statement::TryStatement(ts) => self.count_try_statement(ts, ctx),
_ => {}
}
}
pub(crate) fn emit_exception_domain(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
match stmt {
Statement::ThrowStatement(_) => self.emit_throw_statement(stmt, ctx),
crates/oxide_compiler/src/stmt/exception/try_catch.rs
+4 -63
View File
@@ -3,71 +3,19 @@ use oxide_bytecode::opcode::{self, OpCode};
use oxide_parser::{Statement, VariableDeclarationKind};
impl Compiler {
pub(crate) fn count_try_statement(&self, stmt: &oxide_parser::TryStatement<'_>, ctx: &mut CompileCtx) {
let id = ctx.next_label_id();
let catch_label = Label::CatchBody(id);
let try_end_label = Label::TryEnd(id);
let has_catch = stmt.handler.is_some();
let has_finally = stmt.finalizer.is_some();
ctx.alloc_reg();
if has_finally {
ctx.projected_pc += 1;
}
if has_catch {
ctx.projected_pc += 1;
}
for s in &stmt.block.body {
self.count_statement(s, ctx);
}
ctx.projected_pc += 1;
if has_catch {
ctx.projected_pc += 1;
}
let jmp_needed = has_catch || has_finally;
if jmp_needed {
ctx.projected_pc += 1;
}
ctx.labels.label_map.insert(catch_label, ctx.projected_pc);
if let Some(catch) = &stmt.handler {
ctx.push_scope();
if let Some(param) = &catch.param {
ctx.alloc_reg();
if let oxide_parser::BindingPattern::BindingIdentifier(_) = &param.pattern {
ctx.projected_pc += 1;
}
}
for cs in &catch.body.body {
self.count_statement(cs, ctx);
}
ctx.projected_pc += 1;
ctx.pop_scope();
}
if let Some(finally) = &stmt.finalizer {
let finally_label = Label::FinallyBody(id);
ctx.labels.label_map.insert(finally_label, ctx.projected_pc);
for fs in &finally.body {
self.count_statement(fs, ctx);
}
ctx.projected_pc += 1;
ctx.projected_pc += 1;
}
ctx.labels.label_map.insert(try_end_label, ctx.projected_pc);
}
pub(crate) fn emit_try_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
let Statement::TryStatement(ts) = stmt else {
return Ok(None);
};
let id = ctx.next_label_id();
let catch_label = Label::CatchBody(id);
let finally_label = Label::FinallyBody(id);
let try_end_label = Label::TryEnd(id);
let has_catch = ts.handler.is_some();
let has_finally = ts.finalizer.is_some();
let result_reg = ctx.alloc_reg();
let mut try_finally_begin_pos: Option<usize> = None;
if has_finally {
try_finally_begin_pos = Some(ctx.bytecode.len());
ctx.emit(opcode::encode_try_finally_begin(0));
ctx.emit_try_finally_begin_labeled(finally_label);
}
if has_catch {
ctx.emit_try_begin_labeled(catch_label);
@@ -84,7 +32,7 @@ impl Compiler {
}
let jmp_needed = has_catch || has_finally;
if jmp_needed {
let target = if has_finally { Label::FinallyBody(id) } else { try_end_label };
let target = if has_finally { finally_label } else { try_end_label };
ctx.emit_jmp_labeled(target);
}
let catch_label_pc = ctx.bytecode.len();
@@ -108,14 +56,7 @@ impl Compiler {
ctx.pop_scope();
}
if has_finally {
let finally_label = Label::FinallyBody(id);
let finally_label_pc = ctx.bytecode.len();
ctx.labels.label_map.insert(finally_label, finally_label_pc);
if let Some(fb_pos) = try_finally_begin_pos {
let offset = finally_label_pc as isize - (fb_pos as isize);
let offset = ctx.checked_jump_offset(offset);
ctx.bytecode[fb_pos] = opcode::encode_try_finally_begin(offset);
}
ctx.labels.label_map.insert(finally_label, ctx.bytecode.len());
let mut last_finally_result: Option<u8> = None;
for s in &ts.finalizer.as_ref().unwrap().body {
if let Some(r) = self.emit_statement(s, ctx)? {
crates/oxide_compiler/src/stmt/switch.rs
-37
View File
@@ -3,37 +3,6 @@ use oxide_bytecode::opcode::{self, OpCode};
use oxide_parser::Statement;
impl Compiler {
fn count_switch_statement(&self, stmt: &oxide_parser::SwitchStatement<'_>, ctx: &mut CompileCtx) {
let id = ctx.next_label_id();
let end_label = Label::SwitchEnd(id);
ctx.push_switch(end_label);
self.count_expression(&stmt.discriminant, ctx);
let compare_reg_checkpoint = ctx.reg_checkpoint();
let cases = &stmt.cases;
for case in cases.iter() {
if let Some(test) = &case.test {
self.count_expression(test, ctx);
ctx.projected_pc += 1;
ctx.alloc_reg();
ctx.projected_pc += 1;
ctx.restore_reg_checkpoint(compare_reg_checkpoint);
}
}
let has_default = cases.iter().any(|c| c.test.is_none());
if !has_default {
ctx.projected_pc += 1;
}
for (case_idx, case) in cases.iter().enumerate() {
let case_label = Label::SwitchCase(id, case_idx as u32);
ctx.labels.label_map.insert(case_label, ctx.projected_pc);
for s in &case.consequent {
self.count_statement(s, ctx);
}
}
ctx.labels.label_map.insert(end_label, ctx.projected_pc);
ctx.pop_switch();
}
fn emit_switch_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
let Statement::SwitchStatement(sw) = stmt else {
return Ok(None);
@@ -70,12 +39,6 @@ impl Compiler {
Ok(None)
}
pub(crate) fn count_switch_domain(&self, stmt: &Statement, ctx: &mut CompileCtx) {
if let Statement::SwitchStatement(sw) = stmt {
self.count_switch_statement(sw, ctx);
}
}
pub(crate) fn emit_switch_domain(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
match stmt {
Statement::SwitchStatement(_) => self.emit_switch_statement(stmt, ctx),