feat(interpreter): add and lower trap instructions

Author: Alonely0

interpreter/src/ir.rs

@@ -68,8 +68,14 @@ pub enum Instruction {
     UserCall { dest: Reg, start: Reg, end: Reg, name: NonLocal },
     IndirectCall { dest: Reg, start: Reg, end: Reg, name: Arg, ty: ArgTy },
     Jump { to: Label },
-    Return { arg: Arg, ty: ArgTy },
     Branch { then_label: Label, else_label: Label, condition: Reg },
+
+    // Traps
+    Exit { arg: Arg, ty: ArgTy },
+    Return { arg: Arg, ty: ArgTy },
+    ReturnUnassigned,
+    Next,
+    NextFile,
 }
 
 const _: () = const { assert!(size_of::<Instruction>() <= size_of::<u128>()) };
@@ -187,7 +193,7 @@ impl Display for Instruction {
             Self::Jump { to } => {
                 write!(f, "{op} {to}")
             }
-            Self::Return { arg, ty } => {
+            Self::Return { arg, ty } | Self::Exit { arg, ty } => {
                 write!(f, "{op}")?;
                 fmt_arg(f, arg, ty, " ")
             }
@@ -208,6 +214,9 @@ impl Display for Instruction {
             Self::UserCall { dest, start, end, name } => {
                 write!(f, "{dest} <- {op} {name}, {start}..{end}")
             }
+            Self::Next | Self::NextFile | Self::ReturnUnassigned => {
+                write!(f, "{op}")
+            }
         }
     }
 }
@@ -244,8 +253,11 @@ impl Instruction {
             Self::IndirectCall { .. } => "vcall",
             Self::OutputCall { .. } => "out",
             Self::Jump { .. } => "jmp",
-            Self::Return { .. } => "ret",
+            Self::Return { .. } | Self::ReturnUnassigned => "ret",
             Self::Branch { .. } => "brif",
+            Self::Exit { .. } => "exit",
+            Self::Next => "next",
+            Self::NextFile => "nextf",
         }
     }
 }

interpreter/src/ir/lower.rs

@@ -185,10 +185,40 @@ impl<'a> CodeGen<'a> {
                 self.bc
                     .emit(Instruction::OutputCall { start, end, cmd: *name, redir });
             }
+            Statement::Simple(SimpleStatement::Delete(..)) => todo!(),
             Statement::Switch { scrutinee, branches, default } => {
                 self.lower_switch(scrutinee, branches, default.as_ref());
             }
-            _ => todo!(),
+            Statement::ForEach { .. } => todo!(),
+            Statement::Break => todo!(),
+            Statement::Continue => todo!(),
+            Statement::Exit(Some(expr)) => {
+                let dest = self.alloc_reg();
+                self.lower_expr_into(expr, *dest);
+                self.bc
+                    .emit(Instruction::Exit { arg: Arg { reg: *dest }, ty: ArgTy::Reg });
+                self.free_reg(dest);
+            }
+            Statement::Exit(None) => {
+                self.bc
+                    .emit(Instruction::Exit { arg: Arg { imm: 0 }, ty: ArgTy::Imm });
+            }
+            Statement::Return(Some(expr)) => {
+                let dest = self.alloc_reg();
+                self.lower_expr_into(expr, *dest);
+                self.bc
+                    .emit(Instruction::Return { arg: Arg { reg: *dest }, ty: ArgTy::Reg });
+                self.free_reg(dest);
+            }
+            Statement::Return(None) => {
+                self.bc.emit(Instruction::ReturnUnassigned);
+            }
+            Statement::Next => {
+                self.bc.emit(Instruction::Next);
+            }
+            Statement::NextFile => {
+                self.bc.emit(Instruction::NextFile);
+            }
         }
     }
 

interpreter/src/vm.rs

@@ -281,7 +281,6 @@ impl Interpreter<'_> {
                     self.program_counter = label as _;
                     continue;
                 }
-                Instruction::Return { arg: _, ty: _ } => return Ok(Signal::Return),
                 Instruction::Branch { then_label, else_label, condition } => {
                     if self.registers.get(condition).to_bool() {
                         self.program_counter = then_label.0 as _;
@@ -290,6 +289,12 @@ impl Interpreter<'_> {
                     }
                     continue;
                 }
+                // TODO resolve return/exit args.
+                Instruction::Exit { arg: _arg, ty: _ty } => return Ok(Signal::Exit),
+                Instruction::Return { arg: _, ty: _ } => return Ok(Signal::Return),
+                Instruction::ReturnUnassigned => return Ok(Signal::Return),
+                Instruction::Next => return Ok(Signal::Next),
+                Instruction::NextFile => return Ok(Signal::NextFile),
             }
             self.program_counter += 1;
         }