[DATabase] Change Convert* to Update

New Update functionality allows for manipulating every possible thing about a DAT in one location. A step up from just being able to convert. Also allows users to easily change a single thing across multiple DATs.
Secondarily, for sake of clarity, a couple new partial classes were spun off of DATabase until the menus can get cleaned up.

DATabase/DATabase.cs

@@ -24,7 +24,7 @@ namespace SabreTools
 	///		+ This requires implementing a "last updated" data point for all DATs and tracking for "last generate" somewhere
 	/// - Impelement a ToSort folder for DATs that will place DATs in the correct subfolder on Import
 	/// </remarks>
-	public class DATabase
+	public partial class DATabase
 	{
 		// Private required variables
 		private static string _datroot = "DATS";
@@ -73,11 +73,6 @@ namespace SabreTools
 				bare = false,
 				cascade = false,
 				clean = false,
-				convertMiss = false,
-				convertCMP = false,
-				convertRC = false,
-				convertSD = false,
-				convertXml = false,
 				dedup = false,
 				diff = false,
 				gamename = false,
@@ -95,6 +90,11 @@ namespace SabreTools
 				merge = false,
 				norename = false,
 				old = false,
+				outputCMP = false,
+				outputMiss = false,
+				outputRC = false,
+				outputSD = false,
+				outputXML = false,
 				quotes = false,
 				rem = false,
 				romba = false,
@@ -104,13 +104,23 @@ namespace SabreTools
 				trim = false,
 				tsv = false,
 				skip = false,
+				update = false,
 				usegame = true;
 			string addext = "",
 				author = "",
-				cat = "",
+				category = "",
-				desc = "",
+				comment = "",
+				date = "",
+				description = "",
+				email = "",
 				exta = "",
 				extb = "",
+				filename = "",
+				forcemerge = "",
+				forcend = "",
+				forcepack = "",
+				header = "",
+				homepage = "",
 				name = "",
 				manu = "",
 				outdir = "",
@@ -146,30 +156,10 @@ namespace SabreTools
 					case "--cascade":
 						cascade = true;
 						break;
-					case "-cc":
-					case "--convert-cmp":
-						convertCMP = true;
-						break;
 					case "-clean":
 					case "--clean":
 						clean = true;
 						break;
-					case "-cm":
-					case "--convert-miss":
-						convertMiss = true;
-						break;
-					case "-cr":
-					case "--convert-rc":
-						convertRC = true;
-						break;
-					case "-cs":
-					case "--convert-sd":
-						convertSD = true;
-						break;
-					case "-cx":
-					case "--convert-xml":
-						convertXml = true;
-						break;
 					case "-dd":
 					case "--dedup":
 						dedup = true;
@@ -234,6 +224,26 @@ namespace SabreTools
 					case "--old":
 						old = true;
 						break;
+					case "-oc":
+					case "--output-cmp":
+						outputCMP = true;
+						break;
+					case "-om":
+					case "--output-miss":
+						outputMiss = true;
+						break;
+					case "-or":
+					case "--output-rc":
+						outputRC = true;
+						break;
+					case "-os":
+					case "--output-sd":
+						outputSD = true;
+						break;
+					case "-ox":
+					case "--output-xml":
+						outputXML = true;
+						break;
 					case "-q":
 					case "--quotes":
 						quotes = true;
@@ -277,6 +287,10 @@ namespace SabreTools
 					case "--unzip":
 						forceunpack = true;
 						break;
+					case "-ud":
+					case "--update":
+						update = true;
+						break;
 					default:
 						if (arg.StartsWith("-ae=") || arg.StartsWith("--add-ext="))
 						{
@@ -286,13 +300,25 @@ namespace SabreTools
 						{
 							author = arg.Split('=')[1];
 						}
-						else if (arg.StartsWith("-c=") || arg.StartsWith("--cat="))
+						else if (arg.StartsWith("-ca=") || arg.StartsWith("--category="))
 						{
-							cat = arg.Split('=')[1];
+							category = arg.Split('=')[1];
 						}
-						else if (arg.StartsWith("-d=") || arg.StartsWith("--desc="))
+						else if (arg.StartsWith("-co=") || arg.StartsWith("--comment="))
 						{
-							desc = arg.Split('=')[1];
+							comment = arg.Split('=')[1];
+						}
+						else if (arg.StartsWith("-da=") || arg.StartsWith("--date="))
+						{
+							date = arg.Split('=')[1];
+						}
+						else if (arg.StartsWith("-de=") || arg.StartsWith("--desc="))
+						{
+							description = arg.Split('=')[1];
+						}
+						else if (arg.StartsWith("-em=") || arg.StartsWith("--email="))
+						{
+							email = arg.Split('=')[1];
 						}
 						else if (arg.StartsWith("-exta="))
 						{
@@ -302,6 +328,30 @@ namespace SabreTools
 						{
 							extb = arg.Split('=')[1];
 						}
+						else if (arg.StartsWith("-f=") || arg.StartsWith("--filename="))
+						{
+							filename = arg.Split('=')[1];
+						}
+						else if (arg.StartsWith("-fm=") || arg.StartsWith("--forcemerge="))
+						{
+							forcemerge = arg.Split('=')[1];
+						}
+						else if (arg.StartsWith("-fn=") || arg.StartsWith("--forcend="))
+						{
+							forcend = arg.Split('=')[1];
+						}
+						else if (arg.StartsWith("-fp=") || arg.StartsWith("--forcepack="))
+						{
+							forcepack = arg.Split('=')[1];
+						}
+						else if (arg.StartsWith("-h=") || arg.StartsWith("--header="))
+						{
+							header = arg.Split('=')[1];
+						}
+						else if (arg.StartsWith("-hp=") || arg.StartsWith("--homepage="))
+						{
+							homepage = arg.Split('=')[1];
+						}
 						else if (arg.StartsWith("-input="))
 						{
 							inputs.Add(arg.Split('=')[1].Replace("\"", ""));
@@ -342,6 +392,10 @@ namespace SabreTools
 						{
 							repext = arg.Split('=')[1];
 						}
+						else if (arg.StartsWith("-u=") || arg.StartsWith("--url="))
+						{
+							url = arg.Split('=')[1];
+						}
 						else if (arg.StartsWith("-url=") && url == "")
 						{
 							url = arg.Split('=')[1];
@@ -373,8 +427,8 @@ namespace SabreTools
 			}
 
 			// If more than one switch is enabled or help is set, show the help screen
-			if (help || !(add ^ (convertMiss || romba) ^ convertCMP ^ convertRC ^ convertSD ^ convertXml ^ extsplit ^ generate ^ 
+			if (help || !(add ^ extsplit ^ generate ^ genall ^ hashsplit ^ import ^ listsrc ^ listsys ^ (merge || diff) ^
-				genall ^ hashsplit ^ import ^ listsrc ^ listsys ^ (merge || diff) ^ rem ^ stats ^ trim))
+				(update || outputCMP || outputRC || outputSD || outputXML || outputMiss || romba) ^ rem ^ stats ^ trim))
 			{
 				_logger.Error("Only one feature switch is allowed at a time");
 				Build.Help();
@@ -383,8 +437,8 @@ namespace SabreTools
 			}
 
 			// If a switch that requires a filename is set and no file is, show the help screen
-			if (inputs.Count == 0 && ((convertMiss || romba) || convertCMP || convertRC || convertSD
+			if (inputs.Count == 0 && (update || (outputMiss || romba) || outputCMP || outputRC || outputSD
-				|| convertXml || extsplit || hashsplit || (merge || diff) || stats || trim))
+				|| outputXML || extsplit || hashsplit || (merge || diff) || stats || trim))
 			{
 				_logger.Error("This feature requires at least one input");
 				Build.Help();
@@ -426,48 +480,14 @@ namespace SabreTools
 				ListSystems();
 			}
 
-			// Convert DAT to missfile
+			// Convert or update a DAT or folder of DATs
-			else if (convertMiss || romba)
+			else if (update || outputCMP || outputMiss || outputRC || outputSD || outputXML || romba)
 			{
 				foreach (string input in inputs)
 				{
-					InitConvertMiss(input, usegame, prefix, postfix, quotes, repext, addext, gamename, romba, tsv);
+					InitUpdate(input, filename, name, description, category, version, date, author, email, homepage, url, comment, header,
-				}
+						superdat, forcemerge, forcend, forcepack, outputCMP, outputMiss, outputRC, outputSD, outputXML, usegame, prefix,
-			}
+						postfix, quotes, repext, addext, gamename, romba, tsv, outdir, clean);
-
-			// Convert any DAT to CMP DAT
-			else if (convertCMP)
-			{
-				foreach (string input in inputs)
-				{
-					InitConvert(input, OutputFormat.ClrMamePro, outdir, clean);
-				}
-			}
-
-			// Convert any DAT to RC DAT
-			else if (convertRC)
-			{
-				foreach (string input in inputs)
-				{
-					InitConvert(input, OutputFormat.RomCenter, outdir, clean);
-				}
-			}
-
-			// Convert any DAT to SabreDAT
-			else if (convertSD)
-			{
-				foreach (string input in inputs)
-				{
-					InitConvert(input, OutputFormat.SabreDat, outdir, clean);
-				}
-			}
-
-			// Convert any DAT to XML DAT
-			else if (convertXml)
-			{
-				foreach (string input in inputs)
-				{
-					InitConvert(input, OutputFormat.Xml, outdir, clean);
 				}
 			}
 
@@ -526,7 +546,7 @@ namespace SabreTools
 			// Merge, diff, and dedupe at least 2 DATs
 			else if (merge || diff)
 			{
-				InitMergeDiff(inputs, name, desc, cat, version, author, diff, dedup, bare, forceunpack, old, superdat, cascade, inplace, outdir, clean);
+				InitMergeDiff(inputs, name, description, category, version, author, diff, dedup, bare, forceunpack, old, superdat, cascade, inplace, outdir, clean);
 			}
 
 			// Split a DAT by available hashes
@@ -542,7 +562,10 @@ namespace SabreTools
 			}
 
 			// If nothing is set, show the help
+			else
+			{
 				Build.Help();
+			}
 
 			_logger.Close();
 			return;
@@ -1333,185 +1356,6 @@ Make a selection:
 			imp.UpdateDatabase();
 		}
 
-		/// <summary>
-		/// Wrap generating a DAT from the library
-		/// </summary>
-		/// <param name="system">System ID to be used in the DAT (blank means all)</param>
-		/// <param name="norename">True if files should not be renamed with system and/or source in merged mode (default false)</param>
-		/// <param name="old">True if the output file should be in ClrMamePro format (default false)</param>
-		private static void InitGenerate(string systemid, bool norename, bool old)
-		{
-			IGenerate gen = new GenerateTwo(systemid, "" /* sourceid */, _datroot, _outroot, _connectionString, _logger, norename, old);
-			gen.Export();
-		}
-
-		/// <summary>
-		/// Wrap generating all standard DATs from the library
-		/// </summary>
-		private static void InitGenerateAll(bool norename, bool old)
-		{
-			List<string> systems = new List<string>();
-			using (SqliteConnection dbc = new SqliteConnection(_connectionString))
-			{
-				dbc.Open();
-
-				string query = "SELECT id FROM system";
-				using (SqliteCommand slc = new SqliteCommand(query, dbc))
-				{
-					using (SqliteDataReader sldr = slc.ExecuteReader())
-					{
-						// If nothing is found, tell the user and exit
-						if (!sldr.HasRows)
-						{
-							_logger.Warning("No systems found! Please add a system and then try again.");
-							return;
-						}
-
-						while (sldr.Read())
-						{
-							systems.Add(sldr.GetInt32(0).ToString());
-						}
-					}
-				}
-
-				// Loop through the inputs
-				foreach (string system in systems)
-				{
-					_logger.User("Generating DAT for system id " + system);
-					InitGenerate(system, norename, old);
-				}
-			}
-		}
-
-		/// <summary>
-		/// Wrap converting DAT file from any format to any format
-		/// </summary>
-		/// <param name="filename"></param>
-		/// <param name="outputFormat"></param>
-		/// <param name="outdir">Optional param for output directory</param>
-		/// <param name="clean">True to clean the game names to WoD standard, false otherwise (default)</param>
-		private static void InitConvert(string filename, OutputFormat outputFormat, string outdir, bool clean)
-		{
-			// Clean the input strings
-			outdir = outdir.Replace("\"", "");
-			if (outdir != "")
-			{
-				outdir = Path.GetFullPath(outdir) + Path.DirectorySeparatorChar;
-			}
-			filename = filename.Replace("\"", "");
-
-			if (File.Exists(filename))
-			{
-				_logger.User("Converting \"" + Path.GetFileName(filename) + "\"");
-				DatData datdata = new DatData
-				{
-					OutputFormat = outputFormat,
-					MergeRoms = false,
-				};
-				datdata = RomManipulation.Parse(filename, 0, 0, datdata, _logger, true, clean);
-
-				// If the extension matches, append ".new" to the filename
-				string extension = (datdata.OutputFormat == OutputFormat.Xml || datdata.OutputFormat == OutputFormat.SabreDat ? ".xml" : ".dat");
-				if (outdir == "" && Path.GetExtension(filename) == extension)
-				{
-					datdata.FileName += ".new";
-				}
-
-				Output.WriteDatfile(datdata, (outdir == "" ? Path.GetDirectoryName(filename) : outdir), _logger);
-			}
-			else if (Directory.Exists(filename))
-			{
-				filename = Path.GetFullPath(filename) + Path.DirectorySeparatorChar;
-
-				foreach (string file in Directory.EnumerateFiles(filename, "*", SearchOption.AllDirectories))
-				{
-					_logger.User("Converting \"" + Path.GetFullPath(file).Remove(0, filename.Length) + "\"");
-					DatData datdata = new DatData
-					{
-						OutputFormat = outputFormat,
-						MergeRoms = false,
-					};
-					datdata = RomManipulation.Parse(file, 0, 0, datdata, _logger, true, clean);
-
-					// If the extension matches, append ".new" to the filename
-					string extension = (datdata.OutputFormat == OutputFormat.Xml || datdata.OutputFormat == OutputFormat.SabreDat ? ".xml" : ".dat");
-					if (outdir == "" && Path.GetExtension(file) == extension)
-					{
-						datdata.FileName += ".new";
-					}
-
-					Output.WriteDatfile(datdata, (outdir == "" ? Path.GetDirectoryName(file) : outdir + Path.GetDirectoryName(file).Remove(0, filename.Length - 1)), _logger);
-				}
-			}
-			else
-			{
-				_logger.Error("I'm sorry but " + filename + " doesn't exist!");
-			}
-			return;
-		}
-
-		/// <summary>
-		/// Wrap converting a DAT to missfile
-		/// </summary>
-		/// <param name="input">File to be converted</param>
-		/// <param name="usegame">True if games are to be used in output, false if roms are</param>
-		/// <param name="prefix">Generic prefix to be added to each line</param>
-		/// <param name="postfix">Generic postfix to be added to each line</param>
-		/// <param name="quotes">Add quotes to each item</param>
-		/// <param name="repext">Replace all extensions with another</param>
-		/// <param name="addext">Add an extension to all items</param>
-		/// <param name="gamename">Add the dat name as a directory prefix</param>
-		/// <param name="romba">Output files in romba format</param>
-		/// <param name="tsv">Output files in TSV format</param>
-		private static void InitConvertMiss(string input, bool usegame, string prefix, string postfix, bool quotes,
-			string repext, string addext, bool gamename, bool romba, bool tsv)
-		{
-			// Strip any quotations from the name
-			input = input.Replace("\"", "");
-
-			if (input != "" && File.Exists(input))
-			{
-				// Get the full input name
-				input = Path.GetFullPath(input);
-
-				// Get the output name
-				string name = Path.GetFileNameWithoutExtension(input) + "-miss";
-
-				// Read in the roms from the DAT and then write them to the file
-				_logger.User("Converting " + input);
-				DatData datdata = new DatData
-				{
-					OutputFormat = OutputFormat.MissFile,
-
-					UseGame = usegame,
-					Prefix = prefix,
-					Postfix = postfix,
-					AddExt = addext,
-					RepExt = repext,
-					Quotes = quotes,
-					GameName = gamename,
-					Romba = romba,
-					TSV = tsv,
-				};
-				datdata = RomManipulation.Parse(input, 0, 0, datdata, _logger);
-				datdata.FileName += "-miss";
-				datdata.Name += "-miss";
-				datdata.Description += "-miss";
-
-				// Normalize the extensions
-				addext = (addext == "" || addext.StartsWith(".") ? addext : "." + addext);
-				repext = (repext == "" || repext.StartsWith(".") ? repext : "." + repext);
-
-				Output.WriteDatfile(datdata, Path.GetDirectoryName(input), _logger);
-				_logger.User(input + " converted to: " + name);
-				return;
-			}
-			else
-			{
-				_logger.Error("I'm sorry but " + input + "doesn't exist!");
-			}
-		}
-
 		/// <summary>
 		/// Wrap trimming and merging a single DAT
 		/// </summary>

DATabase/DATabase.csproj

@@ -112,9 +112,11 @@
     <Compile Include="DATabase.cs" />
     <Compile Include="ImportExport\ImportTwo.cs" />
     <Compile Include="MergeDiff.cs" />
+    <Compile Include="Partials\DATabase_InitGenerate.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TrimMerge.cs" />
     <Compile Include="Stats.cs" />
+    <Compile Include="Partials\DATabase_InitUpdate.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />

DATabase/Partials/DATabase_InitGenerate.cs

@@ -0,0 +1,60 @@
+using System.Collections.Generic;
+using Mono.Data.Sqlite;
+
+using SabreTools.Helper;
+
+namespace SabreTools
+{
+	public partial class DATabase
+	{
+		/// <summary>
+		/// Wrap generating a DAT from the library
+		/// </summary>
+		/// <param name="system">System ID to be used in the DAT (blank means all)</param>
+		/// <param name="norename">True if files should not be renamed with system and/or source in merged mode (default false)</param>
+		/// <param name="old">True if the output file should be in ClrMamePro format (default false)</param>
+		private static void InitGenerate(string systemid, bool norename, bool old)
+		{
+			IGenerate gen = new GenerateTwo(systemid, "" /* sourceid */, _datroot, _outroot, _connectionString, _logger, norename, old);
+			gen.Export();
+		}
+
+		/// <summary>
+		/// Wrap generating all standard DATs from the library
+		/// </summary>
+		private static void InitGenerateAll(bool norename, bool old)
+		{
+			List<string> systems = new List<string>();
+			using (SqliteConnection dbc = new SqliteConnection(_connectionString))
+			{
+				dbc.Open();
+
+				string query = "SELECT id FROM system";
+				using (SqliteCommand slc = new SqliteCommand(query, dbc))
+				{
+					using (SqliteDataReader sldr = slc.ExecuteReader())
+					{
+						// If nothing is found, tell the user and exit
+						if (!sldr.HasRows)
+						{
+							_logger.Warning("No systems found! Please add a system and then try again.");
+							return;
+						}
+
+						while (sldr.Read())
+						{
+							systems.Add(sldr.GetInt32(0).ToString());
+						}
+					}
+				}
+
+				// Loop through the inputs
+				foreach (string system in systems)
+				{
+					_logger.User("Generating DAT for system id " + system);
+					InitGenerate(system, norename, old);
+				}
+			}
+		}
+	}
+}

DATabase/Partials/DATabase_InitUpdate.cs

@@ -0,0 +1,386 @@
+using System.IO;
+using SabreTools.Helper;
+
+namespace SabreTools
+{
+	public partial class DATabase
+	{
+		/// <summary>
+		/// Wrap converting and updating DAT file from any format to any format
+		/// </summary>
+		/// <param name="input">Input filename</param>
+		/// <param name="filename">New filename</param>
+		/// <param name="name">New name</param>
+		/// <param name="description">New description</param>
+		/// <param name="category">New category</param>
+		/// <param name="version">New version</param>
+		/// <param name="date">New date</param>
+		/// <param name="author">New author</param>
+		/// <param name="email">New email</param>
+		/// <param name="homepage">New homepage</param>
+		/// <param name="url">New URL</param>
+		/// <param name="comment">New comment</param>
+		/// <param name="header">New header</param>
+		/// <param name="superdat">True to set SuperDAT type, false otherwise</param>
+		/// <param name="forcemerge">None, Split, Full</param>
+		/// <param name="forcend">None, Obsolete, Required, Ignore</param>
+		/// <param name="forcepack">None, Zip, Unzip</param>
+		/// <param name="outputCMP">True to output to ClrMamePro format</param>
+		/// <param name="outputMiss">True to output to Missfile format</param>
+		/// <param name="outputRC">True to output to RomCenter format</param>
+		/// <param name="outputSD">True to output to SabreDAT format</param>
+		/// <param name="outputXML">True to output to Logiqx XML format</param>
+		/// <param name="usegame">True if games are to be used in output, false if roms are</param>
+		/// <param name="prefix">Generic prefix to be added to each line</param>
+		/// <param name="postfix">Generic postfix to be added to each line</param>
+		/// <param name="quotes">Add quotes to each item</param>
+		/// <param name="repext">Replace all extensions with another</param>
+		/// <param name="addext">Add an extension to all items</param>
+		/// <param name="gamename">Add the dat name as a directory prefix</param>
+		/// <param name="romba">Output files in romba format</param>
+		/// <param name="tsv">Output files in TSV format</param>
+		/// <param name="outdir">Optional param for output directory</param>
+		/// <param name="clean">True to clean the game names to WoD standard, false otherwise (default)</param>
+		public static void InitUpdate(string input,
+			string filename,
+			string name,
+			string description,
+			string category,
+			string version,
+			string date,
+			string author,
+			string email,
+			string homepage,
+			string url,
+			string comment,
+			string header,
+			bool superdat,
+			string forcemerge,
+			string forcend,
+			string forcepack,
+			bool outputCMP,
+			bool outputMiss,
+			bool outputRC,
+			bool outputSD,
+			bool outputXML,
+			bool usegame,
+			string prefix,
+			string postfix,
+			bool quotes,
+			string repext,
+			string addext,
+			bool gamename,
+			bool romba,
+			bool tsv,
+			string outdir,
+			bool clean)
+		{
+			// Set the special flags
+			ForceMerging fm = ForceMerging.None;
+			switch (forcemerge.ToLowerInvariant())
+			{
+				case "none":
+				default:
+					fm = ForceMerging.None;
+					break;
+				case "split":
+					fm = ForceMerging.Split;
+					break;
+				case "full":
+					fm = ForceMerging.Full;
+					break;
+			}
+
+			ForceNodump fn = ForceNodump.None;
+			switch (forcend.ToLowerInvariant())
+			{
+				case "none":
+				default:
+					fn = ForceNodump.None;
+					break;
+				case "obsolete":
+					fn = ForceNodump.Obsolete;
+					break;
+				case "required":
+					fn = ForceNodump.Required;
+					break;
+				case "ignore":
+					fn = ForceNodump.Ignore;
+					break;
+			}
+
+			ForcePacking fp = ForcePacking.None;
+			switch (forcepack.ToLowerInvariant())
+			{
+				case "none":
+				default:
+					fp = ForcePacking.None;
+					break;
+				case "zip":
+					fp = ForcePacking.Zip;
+					break;
+				case "unzip":
+					fp = ForcePacking.Unzip;
+					break;
+			}
+
+			// Normalize the extensions
+			addext = (addext == "" || addext.StartsWith(".") ? addext : "." + addext);
+			repext = (repext == "" || repext.StartsWith(".") ? repext : "." + repext);
+
+			// Populate the DatData object
+			DatData userInputDat = new DatData
+			{
+				FileName = filename,
+				Name = name,
+				Description = description,
+				Category = category,
+				Version = version,
+				Date = date,
+				Author = author,
+				Email = email,
+				Homepage = homepage,
+				Url = url,
+				Comment = comment,
+				Header = header,
+				Type = (superdat ? "SuperDAT" : null),
+				ForceMerging = fm,
+				ForceNodump = fn,
+				ForcePacking = fp,
+				MergeRoms = false,
+
+				UseGame = usegame,
+				Prefix = prefix,
+				Postfix = postfix,
+				Quotes = quotes,
+				RepExt = repext,
+				AddExt = addext,
+				GameName = gamename,
+				Romba = romba,
+				TSV = tsv,
+			};
+
+			if (outputCMP)
+			{
+				userInputDat.OutputFormat = OutputFormat.ClrMamePro;
+				InitUpdate(input, userInputDat, outdir, clean);
+			}
+			if (outputMiss || romba)
+			{
+				userInputDat.OutputFormat = OutputFormat.MissFile;
+				InitUpdate(input, userInputDat, outdir, clean);
+			}
+			if (outputRC)
+			{
+				userInputDat.OutputFormat = OutputFormat.RomCenter;
+				InitUpdate(input, userInputDat, outdir, clean);
+			}
+			if (outputSD)
+			{
+				userInputDat.OutputFormat = OutputFormat.SabreDat;
+				InitUpdate(input, userInputDat, outdir, clean);
+			}
+			if (outputXML)
+			{
+				userInputDat.OutputFormat = OutputFormat.Xml;
+				InitUpdate(input, userInputDat, outdir, clean);
+			}
+			if (!outputCMP && !(outputMiss || romba) && !outputRC && !outputSD && !outputXML)
+			{
+				InitUpdate(input, userInputDat, outdir, clean);
+			}
+		}
+
+		/// <summary>
+		/// Wrap converting and updating DAT file from any format to any format
+		/// </summary>
+		/// <param name="inputFileName">Name of the input file or folder</param>
+		/// <param name="datdata">User specified inputs contained in a DatData object</param>
+		/// <param name="outputDirectory">Optional param for output directory</param>
+		/// <param name="clean">True to clean the game names to WoD standard, false otherwise (default)</param>
+		public static void InitUpdate(string inputFileName, DatData datdata, string outputDirectory, bool clean = false)
+		{
+			// Clean the input strings
+			outputDirectory = outputDirectory.Replace("\"", "");
+			if (outputDirectory != "")
+			{
+				outputDirectory = Path.GetFullPath(outputDirectory) + Path.DirectorySeparatorChar;
+			}
+			inputFileName = inputFileName.Replace("\"", "");
+
+			if (File.Exists(inputFileName))
+			{
+				_logger.User("Converting \"" + Path.GetFileName(inputFileName) + "\"");
+				datdata = RomManipulation.Parse(inputFileName, 0, 0, datdata, _logger, true, clean);
+
+				// If the extension matches, append ".new" to the filename
+				string extension = (datdata.OutputFormat == OutputFormat.Xml || datdata.OutputFormat == OutputFormat.SabreDat ? ".xml" : ".dat");
+				if (outputDirectory == "" && Path.GetExtension(inputFileName) == extension)
+				{
+					datdata.FileName += ".new";
+				}
+
+				Output.WriteDatfile(datdata, (outputDirectory == "" ? Path.GetDirectoryName(inputFileName) : outputDirectory), _logger);
+			}
+			else if (Directory.Exists(inputFileName))
+			{
+				inputFileName = Path.GetFullPath(inputFileName) + Path.DirectorySeparatorChar;
+
+				foreach (string file in Directory.EnumerateFiles(inputFileName, "*", SearchOption.AllDirectories))
+				{
+					_logger.User("Converting \"" + Path.GetFullPath(file).Remove(0, inputFileName.Length) + "\"");
+					DatData innerDatdata = (DatData)datdata.Clone();
+					innerDatdata.Roms = null;
+					innerDatdata = RomManipulation.Parse(file, 0, 0, innerDatdata, _logger, true, clean);
+
+					// If the extension matches, append ".new" to the filename
+					string extension = (innerDatdata.OutputFormat == OutputFormat.Xml || innerDatdata.OutputFormat == OutputFormat.SabreDat ? ".xml" : ".dat");
+					if (outputDirectory == "" && Path.GetExtension(file) == extension)
+					{
+						innerDatdata.FileName += ".new";
+					}
+
+					Output.WriteDatfile(innerDatdata, (outputDirectory == "" ? Path.GetDirectoryName(file) : outputDirectory + Path.GetDirectoryName(file).Remove(0, inputFileName.Length - 1)), _logger);
+				}
+			}
+			else
+			{
+				_logger.Error("I'm sorry but " + inputFileName + " doesn't exist!");
+			}
+			return;
+		}
+
+		#region OBSOLETE
+
+		/// <summary>
+		/// Wrap converting DAT file from any format to any format
+		/// </summary>
+		/// <param name="filename"></param>
+		/// <param name="outputFormat"></param>
+		/// <param name="outdir">Optional param for output directory</param>
+		/// <param name="clean">True to clean the game names to WoD standard, false otherwise (default)</param>
+		private static void InitConvert(string filename, OutputFormat outputFormat, string outdir, bool clean)
+		{
+			// Clean the input strings
+			outdir = outdir.Replace("\"", "");
+			if (outdir != "")
+			{
+				outdir = Path.GetFullPath(outdir) + Path.DirectorySeparatorChar;
+			}
+			filename = filename.Replace("\"", "");
+
+			if (File.Exists(filename))
+			{
+				_logger.User("Converting \"" + Path.GetFileName(filename) + "\"");
+				DatData datdata = new DatData
+				{
+					OutputFormat = outputFormat,
+					MergeRoms = false,
+				};
+				datdata = RomManipulation.Parse(filename, 0, 0, datdata, _logger, true, clean);
+
+				// If the extension matches, append ".new" to the filename
+				string extension = (datdata.OutputFormat == OutputFormat.Xml || datdata.OutputFormat == OutputFormat.SabreDat ? ".xml" : ".dat");
+				if (outdir == "" && Path.GetExtension(filename) == extension)
+				{
+					datdata.FileName += ".new";
+				}
+
+				Output.WriteDatfile(datdata, (outdir == "" ? Path.GetDirectoryName(filename) : outdir), _logger);
+			}
+			else if (Directory.Exists(filename))
+			{
+				filename = Path.GetFullPath(filename) + Path.DirectorySeparatorChar;
+
+				foreach (string file in Directory.EnumerateFiles(filename, "*", SearchOption.AllDirectories))
+				{
+					_logger.User("Converting \"" + Path.GetFullPath(file).Remove(0, filename.Length) + "\"");
+					DatData datdata = new DatData
+					{
+						OutputFormat = outputFormat,
+						MergeRoms = false,
+					};
+					datdata = RomManipulation.Parse(file, 0, 0, datdata, _logger, true, clean);
+
+					// If the extension matches, append ".new" to the filename
+					string extension = (datdata.OutputFormat == OutputFormat.Xml || datdata.OutputFormat == OutputFormat.SabreDat ? ".xml" : ".dat");
+					if (outdir == "" && Path.GetExtension(file) == extension)
+					{
+						datdata.FileName += ".new";
+					}
+
+					Output.WriteDatfile(datdata, (outdir == "" ? Path.GetDirectoryName(file) : outdir + Path.GetDirectoryName(file).Remove(0, filename.Length - 1)), _logger);
+				}
+			}
+			else
+			{
+				_logger.Error("I'm sorry but " + filename + " doesn't exist!");
+			}
+			return;
+		}
+
+		/// <summary>
+		/// Wrap converting a DAT to missfile
+		/// </summary>
+		/// <param name="input">File to be converted</param>
+		/// <param name="usegame">True if games are to be used in output, false if roms are</param>
+		/// <param name="prefix">Generic prefix to be added to each line</param>
+		/// <param name="postfix">Generic postfix to be added to each line</param>
+		/// <param name="quotes">Add quotes to each item</param>
+		/// <param name="repext">Replace all extensions with another</param>
+		/// <param name="addext">Add an extension to all items</param>
+		/// <param name="gamename">Add the dat name as a directory prefix</param>
+		/// <param name="romba">Output files in romba format</param>
+		/// <param name="tsv">Output files in TSV format</param>
+		private static void InitConvertMiss(string input, bool usegame, string prefix, string postfix, bool quotes,
+			string repext, string addext, bool gamename, bool romba, bool tsv)
+		{
+			// Strip any quotations from the name
+			input = input.Replace("\"", "");
+
+			if (input != "" && File.Exists(input))
+			{
+				// Get the full input name
+				input = Path.GetFullPath(input);
+
+				// Get the output name
+				string name = Path.GetFileNameWithoutExtension(input) + "-miss";
+
+				// Read in the roms from the DAT and then write them to the file
+				_logger.User("Converting " + input);
+				DatData datdata = new DatData
+				{
+					OutputFormat = OutputFormat.MissFile,
+
+					UseGame = usegame,
+					Prefix = prefix,
+					Postfix = postfix,
+					AddExt = addext,
+					RepExt = repext,
+					Quotes = quotes,
+					GameName = gamename,
+					Romba = romba,
+					TSV = tsv,
+				};
+				datdata = RomManipulation.Parse(input, 0, 0, datdata, _logger);
+				datdata.FileName += "-miss";
+				datdata.Name += "-miss";
+				datdata.Description += "-miss";
+
+				// Normalize the extensions
+				addext = (addext == "" || addext.StartsWith(".") ? addext : "." + addext);
+				repext = (repext == "" || repext.StartsWith(".") ? repext : "." + repext);
+
+				Output.WriteDatfile(datdata, Path.GetDirectoryName(input), _logger);
+				_logger.User(input + " converted to: " + name);
+				return;
+			}
+			else
+			{
+				_logger.Error("I'm sorry but " + input + "doesn't exist!");
+			}
+		}
+
+		#endregion
+	}
+}

SabreHelper/Data/Build.cs

@@ -25,6 +25,9 @@ namespace SabreTools.Helper
 			string mid = name + " " + Constants.Version;
 			mid = "|" + mid.PadLeft(((77 - mid.Length) / 2) + mid.Length).PadRight(77) + "|";
 
+			// If we're outputting to console, do fancy things
+			if (!Console.IsOutputRedirected)
+			{
 				// Set the console to ready state
 				ConsoleColor formertext = ConsoleColor.White;
 				ConsoleColor formerback = ConsoleColor.Black;
@@ -52,6 +55,7 @@ namespace SabreTools.Helper
 					Console.BackgroundColor = formerback;
 				}
 			}
+		}
 
 		/// <summary>
 		/// Show the help dialog for a given class
@@ -77,28 +81,6 @@ Options:
 	-system=			System name (system only)
 	-source=			Source name (source only)
 	-url=			URL (source only)
-  -cc, --convert-cmp	Convert any DAT to CMP
-	-clean			Clean game names according to WoD standards
-	-out=			Output directory
-  -cm, --convert-miss	Convert from DAT to miss
-	-r, --roms		Output roms to miss instead of sets
-	-gp, --game-prefix	Add game name as a prefix to each item
-	-pre=, --prefix=	Set prefix to be printed in front of all lines
-	-post=, --postfix=	Set postfix to be printed behind all lines
-	-q, --quotes		Put double-quotes around each item
-	-ae=, --add-ext=	Add an extension to each item
-	-re=, --rep-ext=	Replace all extensions with specified
-	-ro, --romba		Output roms in Romba format (requires SHA-1)
-	-tsv, --tsv		Output roms in Tab-Separated Value format
-  -cs, --convert-sd	Convert any DAT to SabreDAT
-	-clean			Clean game names according to WoD standards
-	-out=			Output directory
-  -cr, --convert-rc	Convert any DAT to RomCenter
-	-clean			Clean game names according to WoD standards
-	-out=			Output directory
-  -cx, --convert-xml	Convert any DAT to XML
-	-clean			Clean game names according to WoD standards
-	-out=			Output directory
   -es, --ext-split		Split a DAT by two file extensions
 	-exta=			First extension to split by
 	-extb=			Second extension to split by
@@ -128,8 +110,8 @@ Options:
 	-out=			Output directory (overridden by --inplace)
 	-sd, --superdat		Enable SuperDAT creation
 	-n=, --name=		Set the internal name of the DAT
-	-d=, --desc=		Set the filename and description of the DAT
+	-de=, --desc=		Set the filename and description of the DAT
-	-c=, --cat=		Set the category of the DAT
+	-ca=, --category=	Set the category of the DAT
 	-v=, --version=		Set the version of the DAT
 	-au=, --author=		Set the author of the DAT
   -rm, --remove		Remove a system or source from the database
@@ -141,6 +123,52 @@ Options:
 	-rd=, --root-dir=	Set the root directory for trimming calculation
 	-nr, --no-rename	Keep game names instead of using '!'
 	-df, --disable-force	Disable forceunzipping
+  -ud, --update		Update a DAT file
+	-oc, --output-cmp	Output in CMP format
+	-om, --output-miss	Output in Missfile format
+	  -r, --roms		Output roms to miss instead of sets
+	  -gp, --game-prefix	Add game name as a prefix to each item
+	  -pre=, --prefix=	Set prefix to be printed in front of all lines
+	  -post=, --postfix=	Set postfix to be printed behind all lines
+	  -q, --quotes		Put double-quotes around each item
+	  -ae=, --add-ext=	Add an extension to each item
+	  -re=, --rep-ext=	Replace all extensions with specified
+	  -ro, --romba		Output roms in Romba format (requires SHA-1)
+	  -tsv, --tsv		Output roms in Tab-Separated Value format
+	-or, --output-rc	Output in RomCenter format
+	-os, --output-sd	Output in SabreDAT format
+	-ox, --output-xml	Output in Logiqx XML format
+	-f=, --filename=	Set a new filename
+	-n=, --name=		Set a new internal name
+	-de=, --desc=		Set a new description
+	-ca=, --category=	Set a new category
+	-v=, --version=		Set a new version
+	-da=, --date=		Set a new date
+	-au=, --author=		Set a new author
+	-em=, --email=		Set a new email
+	-hp=, --homepage=	Set a new homepage
+	-u=, --url=		Set a new URL
+	-co=, --comment=	Set a new comment
+	-h=, --header=		Set a new header skipper
+	-sd=, --superdat	Set SuperDAT type
+	-fm=, --forcemerge=	Set force merging
+		Supported values are:
+		- None
+		- Split
+		- Full
+	-fn=, --forcend=	Set force nodump
+		Supported values are:
+		- None
+		- Obsolete
+		- Required
+		- Ignore
+	-fp=, --forcepack=	Set force packing
+		Supported values are:
+		- None
+		- Zip
+		- Unzip
+	-clean			Clean game names according to WoD standards
+	-out=			Output directory
 
 Filenames and directories can't start with a reserved string
 unless prefixed by 'input='

SabreHelper/Data/Structs.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace SabreTools.Helper
 {
@@ -28,7 +29,7 @@ namespace SabreTools.Helper
 	/// <summary>
 	/// Intermediate struct for holding DAT information
 	/// </summary>
-	public struct DatData
+	public struct DatData : ICloneable
 	{
 		// Data common to most DAT types
 		public string FileName;
@@ -70,5 +71,47 @@ namespace SabreTools.Helper
 		public long MD5Count;
 		public long SHA1Count;
 		public long NodumpCount;
+
+		public object Clone()
+		{
+			return new DatData
+			{
+				FileName = this.FileName,
+				Name = this.Name,
+				Description = this.Description,
+				Category = this.Category,
+				Version = this.Version,
+				Date = this.Date,
+				Author = this.Author,
+				Email = this.Email,
+				Homepage = this.Homepage,
+				Url = this.Url,
+				Comment = this.Comment,
+				Header = this.Header,
+				Type = this.Type,
+				ForceMerging = this.ForceMerging,
+				ForceNodump = this.ForceNodump,
+				ForcePacking = this.ForcePacking,
+				OutputFormat = this.OutputFormat,
+				MergeRoms = this.MergeRoms,
+				Roms = this.Roms,
+				UseGame = this.UseGame,
+				Prefix = this.Prefix,
+				Postfix = this.Postfix,
+				Quotes = this.Quotes,
+				RepExt = this.RepExt,
+				AddExt = this.AddExt,
+				GameName = this.GameName,
+				Romba = this.Romba,
+				TSV = this.TSV,
+				RomCount = this.RomCount,
+				DiskCount = this.DiskCount,
+				TotalSize = this.TotalSize,
+				CRCCount = this.CRCCount,
+				MD5Count = this.MD5Count,
+				SHA1Count = this.SHA1Count,
+				NodumpCount = this.NodumpCount,
+			};
+		}
 	}
 }