[Skipper] Rearrange Skipper methods without changing logic

SabreTools.Helper/Objects/Dat/DatFile.cs

@@ -4564,11 +4564,12 @@ namespace SabreTools.Helper
 		/// <param name="addDate">True if dates should be archived for all files, false otherwise</param>
 		/// <param name="tempDir">Name of the directory to create a temp folder in (blank is current directory)</param>
 		/// <param name="copyFiles">True if files should be copied to the temp directory before hashing, false otherwise</param>
-		/// <param name="tryRemoveHeader">True if headers should be removed from files if possible, false otherwise</param>
+		/// <param name="headerToCheckAgainst">Populated string representing the name of the skipper to use, a blank string to use the first available checker, null otherwise</param>
 		/// <param name="maxDegreeOfParallelism">Integer representing the maximum amount of parallelization to be used</param>
 		/// <param name="logger">Logger object for console and file output</param>
 		public bool PopulateDatFromDir(string basePath, bool noMD5, bool noSHA1, bool bare, bool archivesAsFiles,
-			bool enableGzip, bool addBlanks, bool addDate, string tempDir, bool copyFiles, bool tryRemoveHeader, int maxDegreeOfParallelism, Logger logger)
+			bool enableGzip, bool addBlanks, bool addDate, string tempDir, bool copyFiles, string headerToCheckAgainst,
+			int maxDegreeOfParallelism, Logger logger)
 		{
 			// If the description is defined but not the name, set the name from the description
 			if (String.IsNullOrEmpty(Name) && !String.IsNullOrEmpty(Description))
@@ -4599,7 +4600,7 @@ namespace SabreTools.Helper
 				item =>
 				{
 					DFDProcessPossibleArchive(item, basePath, noMD5, noSHA1, bare, archivesAsFiles, enableGzip, addBlanks, addDate,
-						tempDir, copyFiles, tryRemoveHeader, maxDegreeOfParallelism, logger);
+						tempDir, copyFiles, headerToCheckAgainst, maxDegreeOfParallelism, logger);
 				});
 
 			// Now find all folders that are empty, if we are supposed to
@@ -4688,11 +4689,12 @@ namespace SabreTools.Helper
 		/// <param name="addDate">True if dates should be archived for all files, false otherwise</param>
 		/// <param name="tempDir">Name of the directory to create a temp folder in (blank is current directory)</param>
 		/// <param name="copyFiles">True if files should be copied to the temp directory before hashing, false otherwise</param>
-		/// <param name="tryRemoveHeader">True if headers should be removed from files if possible, false otherwise</param>
+		/// <param name="headerToCheckAgainst">Populated string representing the name of the skipper to use, a blank string to use the first available checker, null otherwise</param>
 		/// <param name="maxDegreeOfParallelism">Integer representing the maximum amount of parallelization to be used</param>
 		/// <param name="logger">Logger object for console and file output</param>
 		private void DFDProcessPossibleArchive(string item, string basePath, bool noMD5, bool noSHA1, bool bare, bool archivesAsFiles,
-			bool enableGzip, bool addBlanks, bool addDate, string tempDir, bool copyFiles, bool tryRemoveHeader, int maxDegreeOfParallelism, Logger logger)
+			bool enableGzip, bool addBlanks, bool addDate, string tempDir, bool copyFiles, string headerToCheckAgainst,
+			int maxDegreeOfParallelism, Logger logger)
 		{
 			// Define the temporary directory
 			string tempSubDir = Path.GetFullPath(Path.Combine(tempDir, Path.GetRandomFileName())) + Path.DirectorySeparatorChar;
@@ -4762,7 +4764,7 @@ namespace SabreTools.Helper
 				// Otherwise, just get the info on the file itself
 				else if (File.Exists(newItem))
 				{
-					DFDProcessFile(newItem, "", newBasePath, noMD5, noSHA1, addDate, tryRemoveHeader, logger);
+					DFDProcessFile(newItem, "", newBasePath, noMD5, noSHA1, addDate, headerToCheckAgainst, logger);
 				}
 			}
 			// Otherwise, attempt to extract the files to the temporary directory
@@ -4794,14 +4796,14 @@ namespace SabreTools.Helper
 								noMD5,
 								noSHA1,
 								addDate,
-								tryRemoveHeader,
+								headerToCheckAgainst,
 								logger);
 						});
 				}
 				// Otherwise, just get the info on the file itself
 				else if (File.Exists(newItem))
 				{
-					DFDProcessFile(newItem, "", newBasePath, noMD5, noSHA1, addDate, tryRemoveHeader, logger);
+					DFDProcessFile(newItem, "", newBasePath, noMD5, noSHA1, addDate, headerToCheckAgainst, logger);
 				}
 			}
 
@@ -4831,12 +4833,12 @@ namespace SabreTools.Helper
 		/// <param name="noMD5">True if MD5 hashes should be skipped over, false otherwise</param>
 		/// <param name="noSHA1">True if SHA-1 hashes should be skipped over, false otherwise</param>
 		/// <param name="addDate">True if dates should be archived for all files, false otherwise</param>
-		/// <param name="tryRemoveHeader">True if headers should be removed from files if possible, false otherwise</param>
+		/// <param name="headerToCheckAgainst">Populated string representing the name of the skipper to use, a blank string to use the first available checker, null otherwise</param>
 		/// <param name="logger">Logger object for console and file output</param>
-		private void DFDProcessFile(string item, string parent, string basePath, bool noMD5, bool noSHA1, bool addDate, bool tryRemoveHeader, Logger logger)
+		private void DFDProcessFile(string item, string parent, string basePath, bool noMD5, bool noSHA1, bool addDate, string headerToCheckAgainst, Logger logger)
 		{
 			logger.Verbose(Path.GetFileName(item) + " treated like a file");
-			Rom rom = FileTools.GetFileInfo(item, logger, noMD5: noMD5, noSHA1: noSHA1, date: addDate, tryRemoveHeader: tryRemoveHeader);
+			Rom rom = FileTools.GetFileInfo(item, logger, noMD5: noMD5, noSHA1: noSHA1, date: addDate, header: headerToCheckAgainst);
 
 			DFDProcessFileHelper(item, rom, basePath, parent, logger);
 		}

SabreTools.Helper/Objects/SimpleSort.cs

@@ -139,7 +139,7 @@ namespace SabreTools.Helper
 			{
 				_datdata.PopulateDatFromDir(input, false /* noMD5 */, false /* noSHA1 */, true /* bare */, false /* archivesAsFiles */,
 					true /* enableGzip */, false /* addBlanks */, false /* addDate */, "" /* tempDir */, false /* copyFiles */,
-					false /* removeHeader */, 4 /* maxDegreeOfParallelism */, _logger);
+					null /* headerToCheckAgainst */, 4 /* maxDegreeOfParallelism */, _logger);
 			}
 
 			// Setup the fixdat
@@ -486,7 +486,7 @@ namespace SabreTools.Helper
 
 			// Now attempt to see if the file has a header
 			FileStream input = File.OpenRead(file);
-			SkipperRule rule = Skippers.GetMatchingRule(input, "", _logger);
+			SkipperRule rule = Skipper.GetMatchingRule(input, "", _logger);
 
 			// If there's a match, get the new information from the stream
 			if (rule.Tests != null && rule.Tests.Count != 0)
@@ -495,7 +495,7 @@ namespace SabreTools.Helper
 				MemoryStream output = new MemoryStream();
 
 				// Transform the stream and get the information from it
-				Skippers.TransformStream(input, output, rule, _logger, false, true);
+				rule.TransformStream(input, output, _logger, false, true);
 				Rom romNH = FileTools.GetStreamInfo(output, output.Length);
 				romNH.Name = "HEAD::" + rom.Name;
 				romNH.MachineName = rom.MachineName;
@@ -610,14 +610,14 @@ namespace SabreTools.Helper
 				}
 
 				// Now get the transformed file if it exists
-				SkipperRule rule = Skippers.GetMatchingRule(input, "", _logger);
+				SkipperRule rule = Skipper.GetMatchingRule(input, "", _logger);
 
 				// If we have have a non-empty rule, apply it
 				if (rule.Tests != null && rule.Tests.Count != 0)
 				{
 					// Otherwise, apply the rule to the file
 					string newinput = input + ".new";
-					Skippers.TransformFile(input, newinput, rule, _logger);
+					rule.TransformFile(input, newinput, _logger);
 					Rom drom = FileTools.GetFileInfo(newinput, _logger);
 
 					// If we have a blank RomData, it's an error

SabreTools.Helper/Objects/Skippers/Skipper.cs

@@ -0,0 +1,520 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Xml;
+
+namespace SabreTools.Helper
+{
+	public class Skipper
+	{
+		#region Fields
+
+		public string Name;
+		public string Author;
+		public string Version;
+		public List<SkipperRule> Rules;
+		public string SourceFile;
+
+		// Local paths
+		public const string LocalPath = "Skippers";
+
+		// Header skippers represented by a list of skipper objects
+		private static List<Skipper> _list;
+		public static List<Skipper> List
+		{
+			get
+			{
+				if (_list == null || _list.Count == 0)
+				{
+					PopulateSkippers();
+				}
+				return _list;
+			}
+		}
+
+		#endregion
+
+		#region Constructors
+
+		public Skipper()
+		{
+			Name = "";
+			Author = "";
+			Version = "";
+			Rules = new List<SkipperRule>();
+			SourceFile = "";
+		}
+
+		public Skipper(string filename)
+		{
+			Rules = new List<SkipperRule>();
+			SourceFile = Path.GetFileNameWithoutExtension(filename);
+
+			Logger logger = new Logger(false, "");
+			XmlReader xtr = FileTools.GetXmlTextReader(filename, logger);
+
+			if (xtr == null)
+			{
+				return;
+			}
+
+			bool valid = false;
+			xtr.MoveToContent();
+			while (!xtr.EOF)
+			{
+				if (xtr.NodeType != XmlNodeType.Element)
+				{
+					xtr.Read();
+				}
+
+				switch (xtr.Name.ToLowerInvariant())
+				{
+					case "detector":
+						valid = true;
+						xtr.Read();
+						break;
+					case "name":
+						Name = xtr.ReadElementContentAsString();
+						break;
+					case "author":
+						Author = xtr.ReadElementContentAsString();
+						break;
+					case "version":
+						Version = xtr.ReadElementContentAsString();
+						break;
+					case "rule":
+						// Get the information from the rule first
+						SkipperRule rule = new SkipperRule
+						{
+							StartOffset = 0,
+							EndOffset = 0,
+							Operation = HeaderSkipOperation.None,
+							Tests = new List<SkipperTest>(),
+							SourceFile = Path.GetFileNameWithoutExtension(filename),
+						};
+
+						if (xtr.GetAttribute("start_offset") != null)
+						{
+							string offset = xtr.GetAttribute("start_offset");
+							if (offset.ToLowerInvariant() == "eof")
+							{
+								rule.StartOffset = null;
+							}
+							else
+							{
+								rule.StartOffset = Convert.ToInt64(offset, 16);
+							}
+						}
+						if (xtr.GetAttribute("end_offset") != null)
+						{
+							string offset = xtr.GetAttribute("end_offset");
+							if (offset.ToLowerInvariant() == "eof")
+							{
+								rule.EndOffset = null;
+							}
+							else
+							{
+								rule.EndOffset = Convert.ToInt64(offset, 16);
+							}
+						}
+						if (xtr.GetAttribute("operation") != null)
+						{
+							string operation = xtr.GetAttribute("operation");
+							switch (operation.ToLowerInvariant())
+							{
+								case "bitswap":
+									rule.Operation = HeaderSkipOperation.Bitswap;
+									break;
+								case "byteswap":
+									rule.Operation = HeaderSkipOperation.Byteswap;
+									break;
+								case "wordswap":
+									rule.Operation = HeaderSkipOperation.Wordswap;
+									break;
+							}
+						}
+
+						// Now read the individual tests into the Rule
+						XmlReader subreader = xtr.ReadSubtree();
+
+						if (subreader != null)
+						{
+							while (!subreader.EOF)
+							{
+								if (subreader.NodeType != XmlNodeType.Element)
+								{
+									subreader.Read();
+								}
+
+								// Get the test type
+								SkipperTest test = new SkipperTest
+								{
+									Offset = 0,
+									Value = new byte[0],
+									Result = true,
+									Mask = new byte[0],
+									Size = 0,
+									Operator = HeaderSkipTestFileOperator.Equal,
+								};
+								switch (subreader.Name.ToLowerInvariant())
+								{
+									case "data":
+										test.Type = HeaderSkipTest.Data;
+										break;
+									case "or":
+										test.Type = HeaderSkipTest.Or;
+										break;
+									case "xor":
+										test.Type = HeaderSkipTest.Xor;
+										break;
+									case "and":
+										test.Type = HeaderSkipTest.And;
+										break;
+									case "file":
+										test.Type = HeaderSkipTest.File;
+										break;
+									default:
+										subreader.Read();
+										break;
+								}
+
+								// Now populate all the parts that we can
+								if (subreader.GetAttribute("offset") != null)
+								{
+									string offset = subreader.GetAttribute("offset");
+									if (offset.ToLowerInvariant() == "eof")
+									{
+										test.Offset = null;
+									}
+									else
+									{
+										test.Offset = Convert.ToInt64(offset, 16);
+									}
+								}
+								if (subreader.GetAttribute("value") != null)
+								{
+									string value = subreader.GetAttribute("value");
+
+									// http://stackoverflow.com/questions/321370/how-can-i-convert-a-hex-string-to-a-byte-array
+									test.Value = new byte[value.Length / 2];
+									for (int index = 0; index < test.Value.Length; index++)
+									{
+										string byteValue = value.Substring(index * 2, 2);
+										test.Value[index] = byte.Parse(byteValue, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+									}
+								}
+								if (subreader.GetAttribute("result") != null)
+								{
+									string result = subreader.GetAttribute("result");
+									switch (result.ToLowerInvariant())
+									{
+										case "false":
+											test.Result = false;
+											break;
+										case "true":
+										default:
+											test.Result = true;
+											break;
+									}
+								}
+								if (subreader.GetAttribute("mask") != null)
+								{
+									string mask = subreader.GetAttribute("mask");
+
+									// http://stackoverflow.com/questions/321370/how-can-i-convert-a-hex-string-to-a-byte-array
+									test.Mask = new byte[mask.Length / 2];
+									for (int index = 0; index < test.Mask.Length; index++)
+									{
+										string byteValue = mask.Substring(index * 2, 2);
+										test.Mask[index] = byte.Parse(byteValue, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+									}
+								}
+								if (subreader.GetAttribute("size") != null)
+								{
+									string size = subreader.GetAttribute("size");
+									if (size.ToLowerInvariant() == "po2")
+									{
+										test.Size = null;
+									}
+									else
+									{
+										test.Size = Convert.ToInt64(size, 16);
+									}
+								}
+								if (subreader.GetAttribute("operator") != null)
+								{
+									string oper = subreader.GetAttribute("operator");
+									switch (oper.ToLowerInvariant())
+									{
+										case "less":
+											test.Operator = HeaderSkipTestFileOperator.Less;
+											break;
+										case "greater":
+											test.Operator = HeaderSkipTestFileOperator.Greater;
+											break;
+										case "equal":
+										default:
+											test.Operator = HeaderSkipTestFileOperator.Equal;
+											break;
+									}
+								}
+
+								// Add the created test to the rule
+								rule.Tests.Add(test);
+								subreader.Read();
+							}
+						}
+
+						// Add the created rule to the skipper
+						Rules.Add(rule);
+						xtr.Skip();
+						break;
+					default:
+						xtr.Read();
+						break;
+				}
+			}
+
+			// If we somehow have an invalid file, zero out the fields
+			if (!valid)
+			{
+				Name = null;
+				Author = null;
+				Version = null;
+				Rules = null;
+				SourceFile = null;
+			}
+		}
+
+		#endregion
+
+		#region Static Methods
+
+		/// <summary>
+		/// Populate the entire list of header Skippers
+		/// </summary>
+		/// <remarks>
+		/// http://mamedev.emulab.it/clrmamepro/docs/xmlheaders.txt
+		/// http://www.emulab.it/forum/index.php?topic=127.0
+		/// </remarks>
+		private static void PopulateSkippers()
+		{
+			if (_list == null)
+			{
+				_list = new List<Skipper>();
+			}
+
+			foreach (string skipperFile in Directory.EnumerateFiles(LocalPath, "*", SearchOption.AllDirectories))
+			{
+				_list.Add(new Skipper(Path.GetFullPath(skipperFile)));
+			}
+		}
+
+		/// <summary>
+		/// Get the SkipperRule associated with a given file
+		/// </summary>
+		/// <param name="input">Name of the file to be checked</param>
+		/// <param name="skipperName">Name of the skipper to be used, blank to find a matching skipper</param>
+		/// <param name="logger">Logger object for file and console output</param>
+		/// <returns>The SkipperRule that matched the file</returns>
+		public static SkipperRule GetMatchingRule(string input, string skipperName, Logger logger)
+		{
+			// If the file doesn't exist, return a blank skipper rule
+			if (!File.Exists(input))
+			{
+				logger.Error("The file '" + input + "' does not exist so it cannot be tested");
+				return new SkipperRule();
+			}
+
+			return GetMatchingRule(File.OpenRead(input), skipperName, logger);
+		}
+
+		/// <summary>
+		/// Get the SkipperRule associated with a given stream
+		/// </summary>
+		/// <param name="input">Name of the file to be checked</param>
+		/// <param name="skipperName">Name of the skipper to be used, blank to find a matching skipper</param>
+		/// <param name="logger">Logger object for file and console output</param>
+		/// <param name="keepOpen">True if the underlying stream should be kept open, false otherwise</param>
+		/// <returns>The SkipperRule that matched the file</returns>
+		public static SkipperRule GetMatchingRule(Stream input, string skipperName, Logger logger, bool keepOpen = false)
+		{
+			SkipperRule skipperRule = new SkipperRule();
+
+			// Loop through and find a Skipper that has the right name
+			logger.Verbose("Beginning search for matching header skip rules");
+			List<Skipper> tempList = new List<Skipper>();
+			tempList.AddRange(List);
+
+			foreach (Skipper skipper in tempList)
+			{
+				// If we're searching for the skipper OR we have a match to an inputted one
+				if (String.IsNullOrEmpty(skipperName)
+					|| (!String.IsNullOrEmpty(skipper.Name) && skipperName.ToLowerInvariant() == skipper.Name.ToLowerInvariant())
+					|| (!String.IsNullOrEmpty(skipper.Name) && skipperName.ToLowerInvariant() == skipper.SourceFile.ToLowerInvariant()))
+				{
+					// Loop through the rules until one is found that works
+					BinaryReader br = new BinaryReader(input);
+
+					foreach (SkipperRule rule in skipper.Rules)
+					{
+						// Always reset the stream back to the original place
+						input.Seek(0, SeekOrigin.Begin);
+
+						// For each rule, make sure it passes each test
+						bool success = true;
+						foreach (SkipperTest test in rule.Tests)
+						{
+							bool result = true;
+							switch (test.Type)
+							{
+								case HeaderSkipTest.Data:
+									// First seek to the correct position
+									if (test.Offset == null)
+									{
+										input.Seek(0, SeekOrigin.End);
+									}
+									else if (test.Offset > 0 && test.Offset <= input.Length)
+									{
+										input.Seek((long)test.Offset, SeekOrigin.Begin);
+									}
+									else if (test.Offset < 0 && Math.Abs((long)test.Offset) <= input.Length)
+									{
+										input.Seek((long)test.Offset, SeekOrigin.End);
+									}
+
+									// Then read and compare bytewise
+									result = true;
+									for (int i = 0; i < test.Value.Length; i++)
+									{
+										try
+										{
+											if (br.ReadByte() != test.Value[i])
+											{
+												result = false;
+												break;
+											}
+										}
+										catch
+										{
+											result = false;
+											break;
+										}
+									}
+
+									// Return if the expected and actual results match
+									success &= (result == test.Result);
+									break;
+								case HeaderSkipTest.Or:
+								case HeaderSkipTest.Xor:
+								case HeaderSkipTest.And:
+									// First seek to the correct position
+									if (test.Offset == null)
+									{
+										input.Seek(0, SeekOrigin.End);
+									}
+									else if (test.Offset > 0 && test.Offset <= input.Length)
+									{
+										input.Seek((long)test.Offset, SeekOrigin.Begin);
+									}
+									else if (test.Offset < 0 && Math.Abs((long)test.Offset) <= input.Length)
+									{
+										input.Seek((long)test.Offset, SeekOrigin.End);
+									}
+
+									result = true;
+									try
+									{
+										// Then apply the mask if it exists
+										byte[] read = br.ReadBytes(test.Mask.Length);
+										byte[] masked = new byte[test.Mask.Length];
+										for (int i = 0; i < read.Length; i++)
+										{
+											masked[i] = (byte)(test.Type == HeaderSkipTest.And ? read[i] & test.Mask[i] :
+												(test.Type == HeaderSkipTest.Or ? read[i] | test.Mask[i] : read[i] ^ test.Mask[i])
+											);
+										}
+
+										// Finally, compare it against the value
+										for (int i = 0; i < test.Value.Length; i++)
+										{
+											if (masked[i] != test.Value[i])
+											{
+												result = false;
+												break;
+											}
+										}
+									}
+									catch
+									{
+										result = false;
+									}
+
+									// Return if the expected and actual results match
+									success &= (result == test.Result);
+									break;
+								case HeaderSkipTest.File:
+									// First get the file size from stream
+									long size = input.Length;
+
+									// If we have a null size, check that the size is a power of 2
+									result = true;
+									if (test.Size == null)
+									{
+										// http://stackoverflow.com/questions/600293/how-to-check-if-a-number-is-a-power-of-2
+										result = (((ulong)size & ((ulong)size - 1)) == 0);
+									}
+									else if (test.Operator == HeaderSkipTestFileOperator.Less)
+									{
+										result = (size < test.Size);
+									}
+									else if (test.Operator == HeaderSkipTestFileOperator.Greater)
+									{
+										result = (size > test.Size);
+									}
+									else if (test.Operator == HeaderSkipTestFileOperator.Equal)
+									{
+										result = (size == test.Size);
+									}
+
+									// Return if the expected and actual results match
+									success &= (result == test.Result);
+									break;
+							}
+						}
+
+						// If we still have a success, then return this rule
+						if (success)
+						{
+							// If we're not keeping the stream open, dispose of the binary reader
+							if (!keepOpen)
+							{
+								input.Dispose();
+							}
+
+							logger.User(" Matching rule found!");
+							return rule;
+						}
+					}
+				}
+			}
+
+			// If we're not keeping the stream open, dispose of the binary reader
+			if (!keepOpen)
+			{
+				input.Dispose();
+			}
+
+			// If we have a blank rule, inform the user
+			if (skipperRule.Tests == null)
+			{
+				logger.Verbose("No matching rule found!");
+			}
+
+			return skipperRule;
+		}
+
+		#endregion
+	}
+}

SabreTools.Helper/Objects/Skippers/SkipperRule.cs

@@ -0,0 +1,211 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace SabreTools.Helper
+{
+	public class SkipperRule
+	{
+		// Public variables
+		public long? StartOffset; // null is EOF
+		public long? EndOffset; // null if EOF
+		public HeaderSkipOperation Operation;
+		public List<SkipperTest> Tests;
+		public string SourceFile;
+
+		/// <summary>
+		/// Transform an input file using the given rule
+		/// </summary>
+		/// <param name="input">Input file name</param>
+		/// <param name="output">Output file name</param>
+		/// <param name="logger">Logger object for file and console output</param>
+		/// <returns>True if the file was transformed properly, false otherwise</returns>
+		public bool TransformFile(string input, string output, Logger logger)
+		{
+			bool success = true;
+
+			// If the input file doesn't exist, fail
+			if (!File.Exists(input))
+			{
+				logger.Error("I'm sorry but '" + input + "' doesn't exist!");
+				return false;
+			}
+
+			// Create the output directory if it doesn't already
+			if (!Directory.Exists(Path.GetDirectoryName(output)))
+			{
+				Directory.CreateDirectory(Path.GetDirectoryName(output));
+			}
+
+			logger.User("Attempting to apply rule to '" + input + "'");
+			success = TransformStream(File.Open(input, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), File.OpenWrite(output), logger);
+
+			// If the output file has size 0, delete it
+			if (new FileInfo(output).Length == 0)
+			{
+				try
+				{
+					File.Delete(output);
+					success = false;
+				}
+				catch
+				{
+					// Don't log this file deletion error
+				}
+			}
+
+			return success;
+		}
+
+		/// <summary>
+		/// Transform an input stream using the given rule
+		/// </summary>
+		/// <param name="input">Input stream</param>
+		/// <param name="output">Output stream</param>
+		/// <param name="logger">Logger object for file and console output</param>
+		/// <param name="keepReadOpen">True if the underlying read stream should be kept open, false otherwise</param>
+		/// <param name="keepWriteOpen">True if the underlying write stream should be kept open, false otherwise</param>
+		/// <returns>True if the file was transformed properly, false otherwise</returns>
+		public bool TransformStream(Stream input, Stream output, Logger logger, bool keepReadOpen = false, bool keepWriteOpen = false)
+		{
+			bool success = true;
+
+			// If the sizes are wrong for the values, fail
+			long extsize = input.Length;
+			if ((Operation > HeaderSkipOperation.Bitswap && (extsize % 2) != 0)
+				|| (Operation > HeaderSkipOperation.Byteswap && (extsize % 4) != 0)
+				|| (Operation > HeaderSkipOperation.Bitswap && (StartOffset == null || StartOffset % 2 == 0)))
+			{
+				logger.Error("The stream did not have the correct size to be transformed!");
+				return false;
+			}
+
+			// Now read the proper part of the file and apply the rule
+			BinaryWriter bw = null;
+			BinaryReader br = null;
+			try
+			{
+				logger.User("Applying found rule to input stream");
+				bw = new BinaryWriter(output);
+				br = new BinaryReader(input);
+
+				// Seek to the beginning offset
+				if (StartOffset == null)
+				{
+					success = false;
+				}
+				else if (Math.Abs((long)StartOffset) > input.Length)
+				{
+					success = false;
+				}
+				else if (StartOffset > 0)
+				{
+					input.Seek((long)StartOffset, SeekOrigin.Begin);
+				}
+				else if (StartOffset < 0)
+				{
+					input.Seek((long)StartOffset, SeekOrigin.End);
+				}
+
+				// Then read and apply the operation as you go
+				if (success)
+				{
+					byte[] buffer = new byte[4];
+					int pos = 0;
+					while (input.Position < (EndOffset != null ? EndOffset : input.Length)
+						&& input.Position < input.Length)
+					{
+						byte b = br.ReadByte();
+						switch (Operation)
+						{
+							case HeaderSkipOperation.Bitswap:
+								// http://stackoverflow.com/questions/3587826/is-there-a-built-in-function-to-reverse-bit-order
+								uint r = b;
+								int s = 7;
+								for (b >>= 1; b != 0; b >>= 1)
+								{
+									r <<= 1;
+									r |= (byte)(b & 1);
+									s--;
+								}
+								r <<= s;
+								buffer[pos] = (byte)r;
+								break;
+							case HeaderSkipOperation.Byteswap:
+								if (pos % 2 == 1)
+								{
+									buffer[pos - 1] = b;
+								}
+								if (pos % 2 == 0)
+								{
+									buffer[pos + 1] = b;
+								}
+								break;
+							case HeaderSkipOperation.Wordswap:
+								buffer[3 - pos] = b;
+								break;
+							case HeaderSkipOperation.WordByteswap:
+								buffer[(pos + 2) % 4] = b;
+								break;
+							case HeaderSkipOperation.None:
+							default:
+								buffer[pos] = b;
+								break;
+						}
+
+						// Set the buffer position to default write to
+						pos = (pos + 1) % 4;
+
+						// If we filled a buffer, flush to the stream
+						if (pos == 0)
+						{
+							bw.Write(buffer);
+							bw.Flush();
+							buffer = new byte[4];
+						}
+					}
+					// If there's anything more in the buffer, write only the left bits
+					for (int i = 0; i < pos; i++)
+					{
+						bw.Write(buffer[i]);
+					}
+				}
+			}
+			catch (Exception ex)
+			{
+				logger.Error(ex.ToString());
+				return false;
+			}
+			finally
+			{
+				// If we're not keeping the read stream open, dispose of the binary reader
+				if (!keepReadOpen)
+				{
+					br?.Dispose();
+				}
+
+				// If we're not keeping the write stream open, dispose of the binary reader
+				if (!keepWriteOpen)
+				{
+					bw?.Dispose();
+				}
+			}
+
+			return success;
+		}
+	}
+
+	/// <summary>
+	/// Intermediate class for storing Skipper Test information
+	/// </summary>
+	public struct SkipperTest
+	{
+		public HeaderSkipTest Type;
+		public long? Offset; // null is EOF
+		public byte[] Value;
+		public bool Result;
+		public byte[] Mask;
+		public long? Size; // null is PO2, "power of 2" filesize
+		public HeaderSkipTestFileOperator Operator;
+	}
+}