Include disc name in generate manifest

Author: pearfalse

Cargo.toml

@@ -12,8 +12,13 @@ path = "src/lib.rs"
 name = "dfs"
 path = "src/main.rs"
 
+[profile.release]
+lto = true
+opt-level = 'z'
+
 [dependencies]
 ascii = ">= 1.0"
 xml-rs = "0.8.4"
 gumdrop = "0.8"
 arrayvec = "0.7.1"
+enum-utils = "0.1.2"

src/dfs/disc.rs

@@ -9,7 +9,8 @@ use crate::support::*;
 
 /// What a DFS-supporting OS would do with a [`Disc`](./struct.Disc.html)
 /// found in the drive during a Shift-BREAK.
-#[derive(Debug, PartialEq, Clone, Copy)]
+#[derive(Debug, PartialEq, Clone, Copy, enum_utils::FromStr)]
+#[enumeration(case_insensitive)]
 #[repr(u8)]
 pub enum BootOption {
 	None = 0,
@@ -57,6 +58,8 @@ pub type DiscName = AsciiName<12>;
 pub struct Disc<'d> {
 	_data: PhantomData<&'d [u8]>,
 
+	// TODO: hold tracks count
+
 	name: DiscName,
 	boot_option: BootOption,
 	cycle: BCD,
@@ -77,10 +80,11 @@ impl<'d> Disc<'d> {
 	}
 
 	pub fn name(&self) -> &AsciiStr { self.name.as_ascii_str() }
-	pub fn set_name(&mut self, new_name: &AsciiPrintingStr) -> Result<(), DFSError> {
-		self.name = DiscName::try_from(new_name.as_ascii_str().as_slice())
-			.map_err(|e| DFSError::InputTooLarge(e.position()))?;
-		Ok(())
+	pub fn set_name(&mut self, new_name: &AsciiPrintingStr) -> Result<(), AsciiNameError> {
+		match AsciiName::try_from(new_name) {
+			Ok(n) => { self.name = n; Ok(()) },
+			Err(e) => Err(e),
+		}
 	}
 
 	pub fn boot_option(&self) -> BootOption { self.boot_option }

src/dfs/file.rs

@@ -44,6 +44,13 @@ impl<'d> File<'d> {
 		self.name.name.as_ascii_str()
 	}
 
+	pub fn set_name(&mut self, new_name: &AsciiPrintingStr) -> Result<(), AsciiNameError> {
+		match AsciiName::<7>::try_from(new_name) {
+			Ok(n) => { self.name.name = n; Ok(()) },
+			Err(e) => Err(e),
+		}
+	}
+
 	pub fn load_addr(&self) -> u32 { self.load_addr }
 	pub fn exec_addr(&self) -> u32 { self.exec_addr }
 	pub fn is_locked(&self) -> bool { self.is_locked }

src/main.rs

@@ -1,12 +1,18 @@
 use dfsdisc::dfs;
+use dfsdisc::support::*;
 
+use std::borrow::Cow;
 use std::io;
 use std::io::Read;
 use std::ffi::{OsStr,OsString};
 use std::fs::File;
+use std::path::{Path,PathBuf};
+use std::str::FromStr;
 
 use gumdrop::Options;
 
+const XML_NAMESPACE: &'static str = "http://pearfalse.com/schemas/2021/dfs-manifest";
+
 #[derive(Debug, Options)]
 struct CliArgs {
 	#[options(help = "print this")]
@@ -21,7 +27,7 @@ enum Subcommand {
 	#[options(help = "dump the contents of a disc image")]
 	Probe(ScProbe),
 	#[options(help = "build a disc image from source files and a manifest")]
-	Build(ScBuild),
+	Pack(ScPack),
 	#[options(help = "unpack a disc image into separate files (and a manifest)")]
 	Unpack(ScUnpack),
 }
@@ -36,7 +42,7 @@ struct ScProbe {
 }
 
 #[derive(Debug, Options)]
-struct ScBuild {
+struct ScPack {
 	#[options()]
 	help: bool,
 
@@ -64,10 +70,7 @@ fn main() {
 	let r = match args.command {
 		Some(Subcommand::Probe(ref probe)) => sc_probe(&*probe.image_file),
 		Some(Subcommand::Unpack(ref unpack)) => sc_unpack(&*unpack.image_file, &*unpack.output),
-		Some(Subcommand::Build(_)) => {
-			eprintln!("not implemented, sorry");
-			Ok(())
-		},
+		Some(Subcommand::Pack(ref pack)) => sc_pack(pack.manifest.as_ref(), pack.output_file.as_ref()),
 		None => {
 			eprintln!("{}", args.self_usage());
 			std::process::exit(1);
@@ -84,6 +87,12 @@ enum CliError {
 	InputTooLarge,
 	Io(io::Error),
 	BadImage(dfs::DFSError),
+	XmlParseError(xml::reader::Error),
+	XmlDfsError(Cow<'static, str>),
+}
+
+impl<O> From<CliError> for Result<O, CliError> {
+	fn from(src: CliError) -> Self { Err(src) }
 }
 
 impl From<io::Error> for CliError {
@@ -92,6 +101,28 @@ impl From<io::Error> for CliError {
 	}
 }
 
+impl From<dfs::DFSError> for CliError {
+	fn from(src: dfs::DFSError) -> Self {
+		Self::BadImage(src)
+	}
+}
+
+impl From<xml::reader::Error> for CliError {
+	fn from(src: xml::reader::Error) -> Self {
+		Self::XmlParseError(src)
+	}
+}
+
+
+type CliResult = Result<(), CliError>;
+
+
+macro_rules! warn {
+	($format:literal $(, $arg:expr)*) => {
+		eprintln!(concat!("warning: ", $format) $(, &($arg))*)
+	};
+}
+
 
 fn read_image(path: &OsStr) -> Result<Vec<u8>, CliError> {
 	let mut data = Vec::new();
@@ -129,8 +160,7 @@ fn sc_probe(image_path: &OsStr) -> Result<(), CliError> {
 	Ok(())
 }
 
-fn sc_unpack(image_path: &OsStr, target: &OsStr) -> Result<(), CliError> {
-	use std::borrow::Cow;
+fn sc_unpack(image_path: &OsStr, target: &OsStr) -> CliResult {
 	use std::fs;
 	use std::io::Write;
 	use ascii::{AsciiChar,AsciiStr};
@@ -144,20 +174,19 @@ fn sc_unpack(image_path: &OsStr, target: &OsStr) -> Result<(), CliError> {
 	const SEPARATOR: AsciiChar = AsciiChar::Slash;
 	let root_namespace = Namespace({
 		let mut map = std::collections::BTreeMap::new();
-		map.insert(String::from(xml::namespace::NS_NO_PREFIX), String::from("http://pearfalse.com/schemas/2021/dfs-manifest"));
+		map.insert(String::from(xml::namespace::NS_NO_PREFIX), String::from(XML_NAMESPACE));
 		map
 	});
 
 	fs::DirBuilder::new()
 		.recursive(true)
 		.create(target)
-		.map_err(CliError::Io)?;
+		?;
 
 	std::env::set_current_dir(target)?;
 
 	let image_data = read_image(image_path)?;
-	let disc = dfs::Disc::from_bytes(&image_data)
-		.map_err(CliError::BadImage)?;
+	let disc = dfs::Disc::from_bytes(&image_data)?;
 
 	let dirs: std::collections::HashSet<dfsdisc::support::AsciiPrintingChar>
 		= disc.files().map(|f| f.dir()).collect();
@@ -175,7 +204,7 @@ fn sc_unpack(image_path: &OsStr, target: &OsStr) -> Result<(), CliError> {
 
 		fs::File::create(<&AsciiStr>::from(&*file_path_buf).as_str())
 			.and_then(|mut f| f.write_all(file.content()))
-			.map_err(CliError::Io)?;
+			?;
 	}
 
 	// create manifest file
@@ -185,7 +214,7 @@ fn sc_unpack(image_path: &OsStr, target: &OsStr) -> Result<(), CliError> {
 			perform_indent: true,
 			pad_self_closing: false,
 			.. Default::default()
-		})).map_err(CliError::Io)?;
+		}))?;
 
 	// begin manifest
 	match (|| {
@@ -198,6 +227,7 @@ fn sc_unpack(image_path: &OsStr, target: &OsStr) -> Result<(), CliError> {
 		// <dfsdisc>
 		let attr_cycle = format!("{}", disc.cycle().into_u8());
 		let start_attrs = [
+			Attribute::new(XmlName::local("name"), disc.name().as_str()),
 			// hardcoding to 100KiB 40T DFS for now. TODO fix this, obviously
 			Attribute::new(XmlName::local("sides"), "1"),
 			Attribute::new(XmlName::local("tracks"), "40"),
@@ -255,8 +285,8 @@ fn sc_unpack(image_path: &OsStr, target: &OsStr) -> Result<(), CliError> {
 		Err(_e) => panic!("Unexpected XML error: {:?}", _e),
 	};
 
-	manifest.into_inner().write_all(b"\n")
-		.map_err(CliError::Io)
+	manifest.into_inner().write_all(b"\n")?;
+	Ok(())
 }
 
 trait FileHeuristics {
@@ -276,3 +306,88 @@ impl FileHeuristics for [u8] {
 		self.len() >= 2 && [self[0], self[1]] == [0xd, 0x0]
 	}
 }
+
+
+fn sc_pack(manifest_path: &Path, image_path: &Path) -> CliResult {
+	use xml::reader::XmlEvent;
+
+	fn dfs_error(s: &'static str) -> CliError {
+		CliError::XmlDfsError(Cow::Borrowed(s))
+	}
+
+	let root = std::fs::canonicalize(manifest_path)
+		.map_err(CliError::Io)?;
+
+	// open and parse manifest file
+	let mut reader = File::open(&*root)
+		.map(xml::EventReader::new)?;
+
+	// CD to path folder
+	std::env::set_current_dir(root.parent().unwrap())?;
+
+	// load files
+
+	// - attempt to get root element
+	match reader.next()? {
+		XmlEvent::StartDocument { version: _, encoding: _, standalone: _ } => {},
+		_ => return Err(CliError::XmlDfsError(Cow::Borrowed("expected XML document start"))),
+	};
+	let mut dfs_image = match reader.next()? {
+		XmlEvent::StartElement {name: _, ref attributes, namespace: _} => {
+			let xmlns = attributes.local_attr("xmlns");
+			match xmlns.map(|attr| attr.value.as_str()) {
+				Some(XML_NAMESPACE) => {},
+				Some(_other) => warn!("document has unexpected XML namespace; wanted '{}'", XML_NAMESPACE),
+				None => warn!("document has no XML namespace; expected '{}'", XML_NAMESPACE),
+			};
+
+			let mut disc = dfs::Disc::new();
+
+			if let Some(name) = attributes.local_attr("name") {
+				let ap_name = AsciiPrintingStr::try_from_str(name.value.as_str())
+					.map_err(|_| dfs_error("invalid disc name"))?;
+				disc.set_name(ap_name).map_err(|e| CliError::XmlDfsError(Cow::Owned(
+					format!("disc name has non-printing or non-ASCII character at position {}", e.position())
+					)))?;
+			}
+
+			if let Some(cycle) = attributes.local_attr("cycle") {
+				*disc.cycle_mut() = u8::from_str(cycle.value.as_str()).ok()
+					.and_then(|r#u8| BCD::from_hex(r#u8).ok())
+					.ok_or_else(|| dfs_error("incorrect cycle count; not valid 2-digit BCD"))?;
+			}
+
+			if let Some(boot_option) = attributes.local_attr("boot") {
+				match dfs::BootOption::from_str(boot_option.value.as_str()) {
+					Ok(bo) => *disc.boot_option_mut() = bo,
+					Err(_) => return Err(dfs_error("invalid boot option"))
+				};
+			}
+
+			Ok(disc)
+		},
+		_ => Err(dfs_error("missing <dfsdisc> start element")),
+	}?;
+
+	// attempt to combine into disc image
+
+
+	// write it out to target
+
+	Ok(())
+}
+
+trait AttributesExt {
+	type Attr;
+
+	fn local_attr(&self, local_name: &str) -> Option<&Self::Attr>;
+}
+
+impl AttributesExt for [xml::attribute::OwnedAttribute] {
+	type Attr = xml::attribute::OwnedAttribute;
+
+	fn local_attr(&self, local_name: &str) -> Option<&Self::Attr> {
+		let target = xml::name::Name::local(local_name);
+		self.iter().find(move |attr| attr.name.borrow() == target)
+	}
+}

src/support.rs

@@ -190,13 +190,28 @@ impl From<AsciiPrintingChar> for AsciiChar {
 	}
 }
 
+impl ascii::ToAsciiChar for AsciiPrintingChar {
+	unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { self.0 }
+
+	fn to_ascii_char(self) -> Result<AsciiChar, ascii::ToAsciiCharError> { Ok(self.0) }
+}
+
 pub type AsciiPrintingStr = [AsciiPrintingChar];
 
 pub trait AsciiPrintingSlice {
+	fn try_from_str(src: &str) -> Result<&AsciiPrintingStr, AsciiPrintingCharError>;
 	fn as_ascii_str(&self) -> &AsciiStr;
 }
 
 impl AsciiPrintingSlice for AsciiPrintingStr {
+	fn try_from_str(src: &str) -> Result<&AsciiPrintingStr, AsciiPrintingCharError> {
+		for &ch in src.as_bytes().iter() {
+			AsciiPrintingChar::from(ch)?;
+		}
+
+		Ok(unsafe { &*(src as *const str as *const [AsciiPrintingChar]) })
+	}
+
 	fn as_ascii_str(&self) -> &AsciiStr {
 		unsafe { &*(self as *const AsciiPrintingStr as *const AsciiStr) }
 	}