fix #10: add c, comma-separated, and logisim output formats; update rust syntax

hlorenzi · hlorenzi · commit 182bea67b3a3 · 2019-06-22T23:29:52.000-03:00
diff --git a/README.md b/README.md
@@ -28,7 +28,8 @@ Usage: customasm [options] <asm-file-1> ... <asm-file-N>
 Options:
     -f, --format FORMAT The format of the output file. Possible formats:
                         binary, binstr, hexstr, bindump, hexdump,
-						mif, intelhex
+						mif, intelhex, deccomma, hexcomma, decc, hexc,
+						logisim8, logisim16
 						
     -o, --output FILE   The name of the output file.
     -p, --print         Print output to stdout instead of writing to a file.
diff --git a/build_wasm.ps1 b/build_wasm.ps1
@@ -1,5 +1,5 @@
 # Build wasm binary
-cargo +nightly build --target wasm32-unknown-unknown --release
+cargo +nightly build --lib --target wasm32-unknown-unknown --release
 
 # Reduce binary size
 wasm-gc "./target/wasm32-unknown-unknown/release/customasm.wasm" -o "./target/wasm32-unknown-unknown/release/customasm.gc.wasm"
diff --git a/src/asm/assembler.rs b/src/asm/assembler.rs
@@ -71,7 +71,7 @@ impl AssemblerState
 	}
 	
 	
-	pub fn process_file<S>(&mut self, report: RcReport, fileserver: &FileServer, filename: S) -> Result<(), ()>
+	pub fn process_file<S>(&mut self, report: RcReport, fileserver: &dyn FileServer, filename: S) -> Result<(), ()>
 	where S: Into<String>
 	{
 		AssemblerParser::parse_file(report.clone(), self, fileserver, filename, None)?;
diff --git a/src/asm/binary_output.rs b/src/asm/binary_output.rs
@@ -220,6 +220,8 @@ impl BinaryOutput
 		let mut index = start_bit;
 		while index < end_bit
 		{
+			result.push_str(&format!(" {:1$X}: ", index / 8, addr_max_width));
+			
 			let mut byte: u8 = 0;
 			for _ in 0..8
 			{
@@ -228,7 +230,6 @@ impl BinaryOutput
 				index += 1;
 			}
 			
-			result.push_str(&format!("{:1$X}: ", index / 8, addr_max_width));
 			result.push_str(&format!("{:02X};\n", byte));
 		}
 		
@@ -280,4 +281,110 @@ impl BinaryOutput
 		result.push_str(":00000001FF");
 		result
 	}
+	
+	
+	pub fn generate_comma(&self, start_bit: usize, end_bit: usize, radix: usize) -> String
+	{
+		let mut result = String::new();
+		
+		let mut index = start_bit;
+		while index < end_bit
+		{
+			let mut byte: u8 = 0;
+			for _ in 0..8
+			{
+				byte <<= 1;
+				byte |= if self.read(index) { 1 } else { 0 };
+				index += 1;
+			}
+			
+			match radix
+			{
+				10 => result.push_str(&format!("{}", byte)),
+				16 => result.push_str(&format!("0x{:02x}", byte)),
+				_  => panic!("invalid radix")
+			}
+			
+			if index < end_bit
+			{ 
+				result.push_str(", ");
+				
+				if (index / 8) % 16 == 0
+					{ result.push('\n'); }
+			}
+		}
+		
+		result
+	}
+	
+	
+	pub fn generate_c_array(&self, start_bit: usize, end_bit: usize, radix: usize) -> String
+	{
+		let mut result = String::new();
+		
+		result.push_str("const unsigned char data[] = {\n");
+		
+		let byte_num = (end_bit - start_bit) / 8 + if (end_bit - start_bit) % 8 != 0 { 1 } else { 0 };
+		let addr_max_width = format!("{:x}", byte_num - 1).len();
+		
+		let mut index = start_bit;
+		result.push_str(&format!("\t/* 0x{:01$x} */ ", 0, addr_max_width));
+		
+		while index < end_bit
+		{
+			let mut byte: u8 = 0;
+			for _ in 0..8
+			{
+				byte <<= 1;
+				byte |= if self.read(index) { 1 } else { 0 };
+				index += 1;
+			}
+			
+			match radix
+			{
+				10 => result.push_str(&format!("{}", byte)),
+				16 => result.push_str(&format!("0x{:02x}", byte)),
+				_  => panic!("invalid radix")
+			}
+			
+			if index < end_bit
+			{ 
+				result.push_str(", ");
+				
+				if (index / 8) % 16 == 0
+				{
+					result.push_str(&format!("\n\t/* 0x{:01$x} */ ", index / 8, addr_max_width));
+				}
+			}
+		}
+		
+		result.push_str("\n};");
+		result
+	}
+	
+	
+	// From: https://github.com/milanvidakovic/customasm/blob/master/src/asm/binary_output.rs#L84
+	pub fn generate_logisim(&self, start_bit: usize, end_bit: usize, bits_per_chunk: usize) -> String
+	{
+		let mut result = String::new();
+		result.push_str("v2.0 raw\n");
+		
+		let mut index = start_bit;
+		while index < end_bit
+		{
+			let mut value: u16 = 0;
+			for _ in 0..bits_per_chunk
+			{
+				value <<= 1;
+				value |= if self.read(index) { 1 } else { 0 };
+				index += 1;
+			}
+			
+			result.push_str(&format!("{:01$x} ", value, bits_per_chunk / 4));
+			if (index / 8) % 16 == 0
+				{ result.push('\n'); }
+		}
+		
+		result
+	}
 }
diff --git a/src/asm/parser.rs b/src/asm/parser.rs
@@ -14,7 +14,7 @@ use num_traits::ToPrimitive;
 
 pub struct AssemblerParser<'a>
 {
-	pub fileserver: &'a FileServer,
+	pub fileserver: &'a dyn FileServer,
 	pub state: &'a mut AssemblerState,
 	pub cur_filename: String,
 	pub parser: Parser
@@ -23,12 +23,12 @@ pub struct AssemblerParser<'a>
 	
 impl<'a> AssemblerParser<'a>
 {
-	pub fn parse_file<S>(report: RcReport, state: &mut AssemblerState, fileserver: &FileServer, filename: S, filename_span: Option<&Span>) -> Result<(), ()>
+	pub fn parse_file<S>(report: RcReport, state: &mut AssemblerState, fileserver: &dyn FileServer, filename: S, filename_span: Option<&Span>) -> Result<(), ()>
 	where S: Into<String>
 	{
 		let filename_owned = filename.into();
 		let chars = fileserver.get_chars(report.clone(), &filename_owned, filename_span)?;
-		let tokens = tokenize(report.clone(), filename_owned.as_ref(), &chars)?;
+		let tokens = tokenize(report.clone(), AsRef::<str>::as_ref(&filename_owned), &chars)?;
 		
 		let mut parser = AssemblerParser
 		{
diff --git a/src/diagn/report.rs b/src/diagn/report.rs
@@ -130,7 +130,7 @@ impl Report
 	}
 	
 	
-	pub fn has_error_at(&self, fileserver: &FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool
+	pub fn has_error_at(&self, fileserver: &dyn FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool
 	{
 		for msg in &self.messages
 		{
@@ -142,7 +142,7 @@ impl Report
 	}
 	
 	
-	fn msg_has_error_at(&self, msg: &Message, fileserver: &FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool
+	fn msg_has_error_at(&self, msg: &Message, fileserver: &dyn FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool
 	{
 		match msg.inner
 		{
@@ -183,7 +183,7 @@ impl Report
 	}
 	
 	
-	pub fn print_all(&self, writer: &mut Write, fileserver: &FileServer)
+	pub fn print_all(&self, writer: &mut dyn Write, fileserver: &dyn FileServer)
 	{
 		for msg in &self.messages
 		{
@@ -193,7 +193,7 @@ impl Report
 	}
 	
 	
-	fn print_msg(&self, writer: &mut Write, fileserver: &FileServer, msg: &Message, indent: usize)
+	fn print_msg(&self, writer: &mut dyn Write, fileserver: &dyn FileServer, msg: &Message, indent: usize)
 	{
 		let kind_label = msg.kind.get_label();
 		let highlight_color = msg.kind.get_color();
@@ -259,14 +259,14 @@ impl Report
 	}
 	
 	
-	fn print_indent(&self, writer: &mut Write, indent: usize)
+	fn print_indent(&self, writer: &mut dyn Write, indent: usize)
 	{
 		for _ in 0..indent
 			{ write!(writer, "     ").unwrap(); }
 	}
 	
 	
-	fn print_msg_src(&self, writer: &mut Write, counter: &CharCounter, highlight_color: &'static str, line1: usize, col1: usize, line2: usize, col2: usize, indent: usize)
+	fn print_msg_src(&self, writer: &mut dyn Write, counter: &CharCounter, highlight_color: &'static str, line1: usize, col1: usize, line2: usize, col2: usize, indent: usize)
 	{
 		let first_line = if (line1 as isize - 2) < 0
 			{ 0 }
@@ -409,13 +409,13 @@ impl RcReport
 	}
 	
 	
-	pub fn has_error_at(&self, fileserver: &FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool
+	pub fn has_error_at(&self, fileserver: &dyn FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool
 	{
 		self.report.borrow_mut().has_error_at(fileserver, filename, line, error_excerpt)
 	}
 	
 	
-	pub fn print_all(&self, writer: &mut Write, fileserver: &FileServer)
+	pub fn print_all(&self, writer: &mut dyn Write, fileserver: &dyn FileServer)
 	{
 		self.report.borrow_mut().print_all(writer, fileserver);
 	}
diff --git a/src/driver.rs b/src/driver.rs
@@ -16,10 +16,16 @@ enum OutputFormat
 	HexDump,
 	Mif,
 	IntelHex,
+	DecComma,
+	HexComma,
+	DecC,
+	HexC,
+	LogiSim8,
+	LogiSim16,
 }
 
 
-pub fn drive(args: &Vec<String>, fileserver: &mut FileServer) -> Result<(), ()>
+pub fn drive(args: &Vec<String>, fileserver: &mut dyn FileServer) -> Result<(), ()>
 {
 	let opts = make_opts();
 	
@@ -43,7 +49,7 @@ pub fn drive(args: &Vec<String>, fileserver: &mut FileServer) -> Result<(), ()>
 }
 
 
-fn drive_inner(report: RcReport, opts: &getopts::Options, args: &Vec<String>, fileserver: &mut FileServer) -> Result<(), bool>
+fn drive_inner(report: RcReport, opts: &getopts::Options, args: &Vec<String>, fileserver: &mut dyn FileServer) -> Result<(), bool>
 {
 	let matches = parse_opts(report.clone(), opts, args).map_err(|_| true)?;
 	
@@ -64,13 +70,20 @@ fn drive_inner(report: RcReport, opts: &getopts::Options, args: &Vec<String>, fi
 	
 	let out_format = match matches.opt_str("f").as_ref().map(|s| s.as_ref())
 	{
-		Some("binstr")   => OutputFormat::BinStr,
-		Some("bindump")  => OutputFormat::BinDump,
-		Some("hexstr")   => OutputFormat::HexStr,
-		Some("hexdump")  => OutputFormat::HexDump,
-		Some("binary")   => OutputFormat::Binary,
-		Some("mif")      => OutputFormat::Mif,
-		Some("intelhex") => OutputFormat::IntelHex,
+		Some("binstr")    => OutputFormat::BinStr,
+		Some("bindump")   => OutputFormat::BinDump,
+		Some("hexstr")    => OutputFormat::HexStr,
+		Some("hexdump")   => OutputFormat::HexDump,
+		Some("binary")    => OutputFormat::Binary,
+		Some("mif")       => OutputFormat::Mif,
+		Some("intelhex")  => OutputFormat::IntelHex,
+		Some("deccomma")  => OutputFormat::DecComma,
+		Some("hexcomma")  => OutputFormat::HexComma,
+		Some("decc")      => OutputFormat::DecC,
+		Some("hexc")      => OutputFormat::HexC,
+		Some("c")         => OutputFormat::HexC,
+		Some("logisim8")  => OutputFormat::LogiSim8,
+		Some("logisim16") => OutputFormat::LogiSim16,
 		
 		None => if out_stdout
 			{ OutputFormat::HexDump }
@@ -110,13 +123,19 @@ fn drive_inner(report: RcReport, opts: &getopts::Options, args: &Vec<String>, fi
 	
 	let output_data = match out_format
 	{
-		OutputFormat::Binary   => assembled.generate_binary  (0, assembled.len()),
-		OutputFormat::BinStr   => assembled.generate_binstr  (0, assembled.len()).bytes().collect::<Vec<u8>>(),
-		OutputFormat::BinDump  => assembled.generate_bindump (0, assembled.len()).bytes().collect::<Vec<u8>>(),
-		OutputFormat::HexStr   => assembled.generate_hexstr  (0, assembled.len()).bytes().collect::<Vec<u8>>(),
-		OutputFormat::HexDump  => assembled.generate_hexdump (0, assembled.len()).bytes().collect::<Vec<u8>>(),
-		OutputFormat::Mif      => assembled.generate_mif     (0, assembled.len()).bytes().collect::<Vec<u8>>(),
-		OutputFormat::IntelHex => assembled.generate_intelhex(0, assembled.len()).bytes().collect::<Vec<u8>>(),
+		OutputFormat::Binary    => assembled.generate_binary  (0, assembled.len()),
+		OutputFormat::BinStr    => assembled.generate_binstr  (0, assembled.len()).bytes().collect::<Vec<u8>>(),
+		OutputFormat::BinDump   => assembled.generate_bindump (0, assembled.len()).bytes().collect::<Vec<u8>>(),
+		OutputFormat::HexStr    => assembled.generate_hexstr  (0, assembled.len()).bytes().collect::<Vec<u8>>(),
+		OutputFormat::HexDump   => assembled.generate_hexdump (0, assembled.len()).bytes().collect::<Vec<u8>>(),
+		OutputFormat::Mif       => assembled.generate_mif     (0, assembled.len()).bytes().collect::<Vec<u8>>(),
+		OutputFormat::IntelHex  => assembled.generate_intelhex(0, assembled.len()).bytes().collect::<Vec<u8>>(),
+		OutputFormat::DecComma  => assembled.generate_comma   (0, assembled.len(), 10).bytes().collect::<Vec<u8>>(),
+		OutputFormat::HexComma  => assembled.generate_comma   (0, assembled.len(), 16).bytes().collect::<Vec<u8>>(),
+		OutputFormat::DecC      => assembled.generate_c_array (0, assembled.len(), 10).bytes().collect::<Vec<u8>>(),
+		OutputFormat::HexC      => assembled.generate_c_array (0, assembled.len(), 16).bytes().collect::<Vec<u8>>(),
+		OutputFormat::LogiSim8  => assembled.generate_logisim (0, assembled.len(), 8).bytes().collect::<Vec<u8>>(),
+		OutputFormat::LogiSim16 => assembled.generate_logisim (0, assembled.len(), 16).bytes().collect::<Vec<u8>>(),
 	};
 	
 	if out_stdout
@@ -145,7 +164,7 @@ fn drive_inner(report: RcReport, opts: &getopts::Options, args: &Vec<String>, fi
 fn make_opts() -> getopts::Options
 {
     let mut opts = getopts::Options::new();
-    opts.optopt("f", "format", "The format of the output file. Possible formats: binary, binstr, hexstr, bindump, hexdump, mif, intelhex", "FORMAT");
+    opts.optopt("f", "format", "The format of the output file. Possible formats: binary, binstr, hexstr, bindump, hexdump, mif, intelhex, deccomma, hexcomma, decc, hexc, logisim8, logisim16", "FORMAT");
     opts.optmulti("i", "include", "Specifies an additional file for processing before the given <asm-files>. [deprecated]", "FILE");
     opts.optopt("o", "output", "The name of the output file.", "FILE");
     opts.optflag("p", "print", "Print output to stdout instead of writing to a file.");
@@ -201,7 +220,7 @@ fn get_default_output_filename(report: RcReport, input_filename: &str) -> Result
 }
 
 
-pub fn assemble(report: RcReport, fileserver: &FileServer, filenames: &[String], quiet: bool) -> Result<BinaryOutput, ()>
+pub fn assemble(report: RcReport, fileserver: &dyn FileServer, filenames: &[String], quiet: bool) -> Result<BinaryOutput, ()>
 {
 	if !quiet
 		{ print_header(); }
diff --git a/src/test/asm.rs b/src/test/asm.rs
@@ -39,15 +39,15 @@ where S: Into<Vec<u8>>
 }
 
 
-fn test_fileserver<S>(fileserver: &FileServer, asm_filename: S, expected: ExpectedResult<(usize, &'static str)>)
+fn test_fileserver<S>(fileserver: &dyn FileServer, asm_filename: S, expected: ExpectedResult<(usize, &'static str)>)
 where S: Into<String>
 {
 	let bits = if let Pass(expected) = expected
 		{ expected.0 }
 	else
 		{ 4 };
 		
-	let assemble = |report: RcReport, fileserver: &FileServer, filename: S| -> Result<(usize, String), ()>
+	let assemble = |report: RcReport, fileserver: &dyn FileServer, filename: S| -> Result<(usize, String), ()>
 	{
 		let mut asm = AssemblerState::new();
 		asm.process_file(report.clone(), fileserver, filename)?;
diff --git a/src/test/cpudef.rs b/src/test/cpudef.rs
@@ -9,7 +9,7 @@ use super::{ExpectedResult, expect_result};
 fn test<S>(src: S, expected: ExpectedResult<()>)
 where S: Into<Vec<u8>>
 {
-	let compile = |report: RcReport, fileserver: &FileServer| -> Result<(), ()>
+	let compile = |report: RcReport, fileserver: &dyn FileServer| -> Result<(), ()>
 	{
 		let chars = fileserver.get_chars(report.clone(), "test", None)?;
 		let tokens = tokenize(report.clone(), "test", &chars)?;
diff --git a/src/test/mod.rs b/src/test/mod.rs
@@ -19,7 +19,7 @@ pub enum ExpectedResult<T>
 }
 
 
-pub fn expect_result<T>(report: RcReport, fileserver: &FileServer, got: Option<T>, expected: ExpectedResult<T>)
+pub fn expect_result<T>(report: RcReport, fileserver: &dyn FileServer, got: Option<T>, expected: ExpectedResult<T>)
 where T: Debug + PartialEq
 {
 	enable_windows_ansi_support();
diff --git a/src/webasm/mod.rs b/src/webasm/mod.rs
diff --git a/web/index.html b/web/index.html
diff --git a/web/main.js b/web/main.js

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ impl AssemblerState`
`71`	`71`	`}`
`72`	`72`
`73`	`73`
`74`		`- pub fn process_file<S>(&mut self, report: RcReport, fileserver: &FileServer, filename: S) -> Result<(), ()>`
	`74`	`+ pub fn process_file<S>(&mut self, report: RcReport, fileserver: &dyn FileServer, filename: S) -> Result<(), ()>`
`75`	`75`	`where S: Into<String>`
`76`	`76`	`{`
`77`	`77`	`AssemblerParser::parse_file(report.clone(), self, fileserver, filename, None)?;`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ use num_traits::ToPrimitive;`
`14`	`14`
`15`	`15`	`pub struct AssemblerParser<'a>`
`16`	`16`	`{`
`17`		`- pub fileserver: &'a FileServer,`
	`17`	`+ pub fileserver: &'a dyn FileServer,`
`18`	`18`	`pub state: &'a mut AssemblerState,`
`19`	`19`	`pub cur_filename: String,`
`20`	`20`	`pub parser: Parser`
`@@ -23,12 +23,12 @@ pub struct AssemblerParser<'a>`
`23`	`23`
`24`	`24`	`impl<'a> AssemblerParser<'a>`
`25`	`25`	`{`
`26`		`- pub fn parse_file<S>(report: RcReport, state: &mut AssemblerState, fileserver: &FileServer, filename: S, filename_span: Option<&Span>) -> Result<(), ()>`
	`26`	`+ pub fn parse_file<S>(report: RcReport, state: &mut AssemblerState, fileserver: &dyn FileServer, filename: S, filename_span: Option<&Span>) -> Result<(), ()>`
`27`	`27`	`where S: Into<String>`
`28`	`28`	`{`
`29`	`29`	`let filename_owned = filename.into();`
`30`	`30`	`let chars = fileserver.get_chars(report.clone(), &filename_owned, filename_span)?;`
`31`		`- let tokens = tokenize(report.clone(), filename_owned.as_ref(), &chars)?;`
	`31`	`+ let tokens = tokenize(report.clone(), AsRef::<str>::as_ref(&filename_owned), &chars)?;`
`32`	`32`
`33`	`33`	`let mut parser = AssemblerParser`
`34`	`34`	`{`
Original file line number	Diff line number	Diff line change
`@@ -130,7 +130,7 @@ impl Report`
`130`	`130`	`}`
`131`	`131`
`132`	`132`
`133`		`- pub fn has_error_at(&self, fileserver: &FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool`
	`133`	`+ pub fn has_error_at(&self, fileserver: &dyn FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool`
`134`	`134`	`{`
`135`	`135`	`for msg in &self.messages`
`136`	`136`	`{`
`@@ -142,7 +142,7 @@ impl Report`
`142`	`142`	`}`
`143`	`143`
`144`	`144`
`145`		`- fn msg_has_error_at(&self, msg: &Message, fileserver: &FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool`
	`145`	`+ fn msg_has_error_at(&self, msg: &Message, fileserver: &dyn FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool`
`146`	`146`	`{`
`147`	`147`	`match msg.inner`
`148`	`148`	`{`
`@@ -183,7 +183,7 @@ impl Report`
`183`	`183`	`}`
`184`	`184`
`185`	`185`
`186`		`- pub fn print_all(&self, writer: &mut Write, fileserver: &FileServer)`
	`186`	`+ pub fn print_all(&self, writer: &mut dyn Write, fileserver: &dyn FileServer)`
`187`	`187`	`{`
`188`	`188`	`for msg in &self.messages`
`189`	`189`	`{`
`@@ -193,7 +193,7 @@ impl Report`
`193`	`193`	`}`
`194`	`194`
`195`	`195`
`196`		`- fn print_msg(&self, writer: &mut Write, fileserver: &FileServer, msg: &Message, indent: usize)`
	`196`	`+ fn print_msg(&self, writer: &mut dyn Write, fileserver: &dyn FileServer, msg: &Message, indent: usize)`
`197`	`197`	`{`
`198`	`198`	`let kind_label = msg.kind.get_label();`
`199`	`199`	`let highlight_color = msg.kind.get_color();`
`@@ -259,14 +259,14 @@ impl Report`
`259`	`259`	`}`
`260`	`260`
`261`	`261`
`262`		`- fn print_indent(&self, writer: &mut Write, indent: usize)`
	`262`	`+ fn print_indent(&self, writer: &mut dyn Write, indent: usize)`
`263`	`263`	`{`
`264`	`264`	`for _ in 0..indent`
`265`	`265`	`{ write!(writer, " ").unwrap(); }`
`266`	`266`	`}`
`267`	`267`
`268`	`268`
`269`		`- fn print_msg_src(&self, writer: &mut Write, counter: &CharCounter, highlight_color: &'static str, line1: usize, col1: usize, line2: usize, col2: usize, indent: usize)`
	`269`	`+ fn print_msg_src(&self, writer: &mut dyn Write, counter: &CharCounter, highlight_color: &'static str, line1: usize, col1: usize, line2: usize, col2: usize, indent: usize)`
`270`	`270`	`{`
`271`	`271`	`let first_line = if (line1 as isize - 2) < 0`
`272`	`272`	`{ 0 }`
`@@ -409,13 +409,13 @@ impl RcReport`
`409`	`409`	`}`
`410`	`410`
`411`	`411`
`412`		`- pub fn has_error_at(&self, fileserver: &FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool`
	`412`	`+ pub fn has_error_at(&self, fileserver: &dyn FileServer, filename: &str, line: usize, error_excerpt: &str) -> bool`
`413`	`413`	`{`
`414`	`414`	`self.report.borrow_mut().has_error_at(fileserver, filename, line, error_excerpt)`
`415`	`415`	`}`
`416`	`416`
`417`	`417`
`418`		`- pub fn print_all(&self, writer: &mut Write, fileserver: &FileServer)`
	`418`	`+ pub fn print_all(&self, writer: &mut dyn Write, fileserver: &dyn FileServer)`
`419`	`419`	`{`
`420`	`420`	`self.report.borrow_mut().print_all(writer, fileserver);`
`421`	`421`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,15 +39,15 @@ where S: Into<Vec<u8>>`
`39`	`39`	`}`
`40`	`40`
`41`	`41`
`42`		`-fn test_fileserver<S>(fileserver: &FileServer, asm_filename: S, expected: ExpectedResult<(usize, &'static str)>)`
	`42`	`+fn test_fileserver<S>(fileserver: &dyn FileServer, asm_filename: S, expected: ExpectedResult<(usize, &'static str)>)`
`43`	`43`	`where S: Into<String>`
`44`	`44`	`{`
`45`	`45`	`let bits = if let Pass(expected) = expected`
`46`	`46`	`{ expected.0 }`
`47`	`47`	`else`
`48`	`48`	`{ 4 };`
`49`	`49`
`50`		`- let assemble = \|report: RcReport, fileserver: &FileServer, filename: S\| -> Result<(usize, String), ()>`
	`50`	`+ let assemble = \|report: RcReport, fileserver: &dyn FileServer, filename: S\| -> Result<(usize, String), ()>`
`51`	`51`	`{`
`52`	`52`	`let mut asm = AssemblerState::new();`
`53`	`53`	`asm.process_file(report.clone(), fileserver, filename)?;`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ use super::{ExpectedResult, expect_result};`
`9`	`9`	`fn test<S>(src: S, expected: ExpectedResult<()>)`
`10`	`10`	`where S: Into<Vec<u8>>`
`11`	`11`	`{`
`12`		`- let compile = \|report: RcReport, fileserver: &FileServer\| -> Result<(), ()>`
	`12`	`+ let compile = \|report: RcReport, fileserver: &dyn FileServer\| -> Result<(), ()>`
`13`	`13`	`{`
`14`	`14`	`let chars = fileserver.get_chars(report.clone(), "test", None)?;`
`15`	`15`	`let tokens = tokenize(report.clone(), "test", &chars)?;`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ pub enum ExpectedResult<T>`
`19`	`19`	`}`
`20`	`20`
`21`	`21`
`22`		`-pub fn expect_result<T>(report: RcReport, fileserver: &FileServer, got: Option<T>, expected: ExpectedResult<T>)`
	`22`	`+pub fn expect_result<T>(report: RcReport, fileserver: &dyn FileServer, got: Option<T>, expected: ExpectedResult<T>)`
`23`	`23`	`where T: Debug + PartialEq`
`24`	`24`	`{`
`25`	`25`	`enable_windows_ansi_support();`