Added lifetime to Parsable trait.

dcb-exe/src/inst/basic.rs

@@ -107,8 +107,8 @@ impl TryEncode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], ctx: &'a Ctx) -> Result<Self, ParseError> {
 		#[rustfmt::skip]
 		let parsers: &[&dyn Fn() -> Result<Self, ParseError>] = &[
 			&|| alu  ::Inst::parse(mnemonic, args, ctx).map(Self::Alu  ),

dcb-exe/src/inst/basic/alu.rs

@@ -39,8 +39,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], ctx: &'a Ctx) -> Result<Self, ParseError> {
 		match imm::Inst::parse(mnemonic, args, ctx) {
 			Ok(inst) => Ok(Self::Imm(inst)),
 			Err(ParseError::UnknownMnemonic) => reg::Inst::parse(mnemonic, args, ctx).map(Self::Reg),

dcb-exe/src/inst/basic/alu/imm.rs

@@ -118,8 +118,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		#[rustfmt::skip]
 		let to_kind = match mnemonic {
 			"addi"  => |value: i64| value.try_into().map(Kind::Add                ),

dcb-exe/src/inst/basic/alu/reg.rs

@@ -132,8 +132,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		#[rustfmt::skip]
 		let kind = match mnemonic {
 			"add"  => Kind::Add                ,

dcb-exe/src/inst/basic/co.rs

@@ -168,8 +168,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		let inst = match mnemonic {
 			"cop0" | "cop1" | "cop2" | "cop3" => {
 				let n = mnemonic[3..].parse().expect("Unable to parse 0..=3");

dcb-exe/src/inst/basic/cond.rs

@@ -120,8 +120,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], ctx: &'a Ctx) -> Result<Self, ParseError> {
 		// Note: Literals are absolute, not relative
 
 		// Calculates the offset between a position and the current one

dcb-exe/src/inst/basic/jmp.rs

@@ -39,8 +39,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], ctx: &'a Ctx) -> Result<Self, ParseError> {
 		match imm::Inst::parse(mnemonic, args, ctx) {
 			Ok(inst) => Ok(Self::Imm(inst)),
 			Err(ParseError::UnknownMnemonic) => reg::Inst::parse(mnemonic, args, ctx).map(Self::Reg),

dcb-exe/src/inst/basic/jmp/imm.rs

@@ -88,8 +88,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], ctx: &'a Ctx) -> Result<Self, ParseError> {
 		let (pos, kind) = match mnemonic {
 			"j" => match args {
 				[arg] => (ctx.arg_pos(arg)?, Kind::Jump),

dcb-exe/src/inst/basic/jmp/reg.rs

@@ -73,8 +73,8 @@ impl Encode for Inst {
 }
 
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		let (target, kind) = match mnemonic {
 			"jr" => match *args {
 				[LineArg::Register(target)] => (target, Kind::Jump),

dcb-exe/src/inst/basic/load.rs

@@ -114,8 +114,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		let kind = match mnemonic {
 			"lb" => Kind::Byte,
 			"lh" => Kind::HalfWord,

dcb-exe/src/inst/basic/lui.rs

@@ -46,8 +46,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		if mnemonic != "lui" {
 			return Err(ParseError::UnknownMnemonic);
 		}

dcb-exe/src/inst/basic/mult.rs

@@ -154,8 +154,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		let inst = match mnemonic {
 			"mflo" | "mfhi" | "mtlo" | "mthi" => {
 				let reg = match *args {

dcb-exe/src/inst/basic/shift.rs

@@ -48,8 +48,8 @@ impl TryEncode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], ctx: &'a Ctx) -> Result<Self, ParseError> {
 		match imm::Inst::parse(mnemonic, args, ctx) {
 			Ok(inst) => Ok(Self::Imm(inst)),
 			Err(ParseError::UnknownMnemonic) => reg::Inst::parse(mnemonic, args, ctx).map(Self::Reg),

dcb-exe/src/inst/basic/shift/imm.rs

@@ -105,8 +105,8 @@ impl TryEncode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		let kind = match mnemonic {
 			"sll" => Kind::LeftLogical,
 			"srl" => Kind::RightLogical,

dcb-exe/src/inst/basic/shift/reg.rs

@@ -91,8 +91,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		let kind = match mnemonic {
 			"sllv" => Kind::LeftLogical,
 			"srlv" => Kind::RightLogical,

dcb-exe/src/inst/basic/store.rs

@@ -104,8 +104,8 @@ impl Encode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		let kind = match mnemonic {
 			"sb" => Kind::Byte,
 			"sh" => Kind::HalfWord,

dcb-exe/src/inst/basic/sys.rs

@@ -86,8 +86,8 @@ impl TryEncode for Inst {
 	}
 }
 
-impl Parsable for Inst {
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], _ctx: &Ctx) -> Result<Self, ParseError> {
+impl<'a> Parsable<'a> for Inst {
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], _ctx: &'a Ctx) -> Result<Self, ParseError> {
 		let kind = match mnemonic {
 			"sys" => Kind::Sys,
 			"break" => Kind::Break,

dcb-exe/src/inst/parse.rs

@@ -13,9 +13,9 @@ use crate::Pos;
 use std::convert::TryInto;
 
 /// Instruction parsing
-pub trait Parsable: Sized {
+pub trait Parsable<'a>: Sized + 'a {
 	/// Parses this instruction
-	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &str, args: &[LineArg], ctx: &Ctx) -> Result<Self, ParseError>;
+	fn parse<Ctx: ?Sized + ParseCtx>(mnemonic: &'a str, args: &'a [LineArg], ctx: &'a Ctx) -> Result<Self, ParseError>;
 }
 
 /// Parsing context