Prep Skippers for XML serialization

SabreTools.Skippers/Enums.cs

@@ -12,18 +12,6 @@
         WordByteswap,
     }
 
-    /// <summary>
-    /// Determines the type of test to be done
-    /// </summary>
-    public enum HeaderSkipTest
-    {
-        Data = 0,
-        Or,
-        Xor,
-        And,
-        File,
-    }
-
     /// <summary>
     /// Determines the operator to be used in a file test
     /// </summary>

SabreTools.Skippers/SkipperFile.cs

@@ -4,6 +4,7 @@ using System.Globalization;
 using System.IO;
 using System.Xml;
 using System.Xml.Schema;
+using System.Xml.Serialization;
 
 namespace SabreTools.Skippers
 {
@@ -20,26 +21,31 @@ namespace SabreTools.Skippers
         /// <summary>
         /// Skipper name
         /// </summary>
+        [XmlElement("name")]
         public string Name { get; set; } = string.Empty;
 
         /// <summary>
         /// Author names
         /// </summary>
+        [XmlElement("author")]
         public string Author { get; set; } = string.Empty;
 
         /// <summary>
         /// File version
         /// </summary>
+        [XmlElement("version")]
         public string Version { get; set; } = string.Empty;
 
         /// <summary>
         /// Set of all rules in the skipper
         /// </summary>
+        [XmlArray("rule")]
         public List<SkipperRule> Rules { get; set; } = new List<SkipperRule>();
 
         /// <summary>
         /// Filename the skipper lives in
         /// </summary>
+        [XmlIgnore]
         public string SourceFile { get; set; } = string.Empty;
 
         #endregion
@@ -129,7 +135,7 @@ namespace SabreTools.Skippers
                             SkipperRule rule = ParseRule(xtr);
                             if (rule != null)
                                 Rules.Add(rule);
-                            
+
                             xtr.Read();
                             break;
 
@@ -227,7 +233,7 @@ namespace SabreTools.Skippers
 
                                 subreader.Read();
                                 break;
-                                
+
                             default:
                                 subreader.Read();
                                 break;
@@ -256,41 +262,27 @@ namespace SabreTools.Skippers
             try
             {
                 // Get the test type
-                SkipperTest test = new SkipperTest
+                SkipperTest test = xtr.Name.ToLowerInvariant() switch
                 {
-                    Offset = 0,
+                    "and" => new AndSkipperTest(),
-                    Value = new byte[0],
+                    "data" => new DataSkipperTest(),
-                    Result = true,
+                    "file" => new FileSkipperTest(),
-                    Mask = new byte[0],
+                    "or" => new OrSkipperTest(),
-                    Size = 0,
+                    "xor" => new XorSkipperTest(),
-                    Operator = HeaderSkipTestFileOperator.Equal,
+                    _ => null,
                 };
 
-                switch (xtr.Name.ToLowerInvariant())
+                // If we had an invalid test type
-                {
+                if (test == null)
-                    case "data":
+                    return null;
-                        test.Type = HeaderSkipTest.Data;
-                        break;
 
-                    case "or":
+                // Set the default values
-                        test.Type = HeaderSkipTest.Or;
+                test.Offset = 0;
-                        break;
+                test.Value = Array.Empty<byte>();
-
+                test.Result = true;
-                    case "xor":
+                test.Mask = Array.Empty<byte>();
-                        test.Type = HeaderSkipTest.Xor;
+                test.Size = 0;
-                        break;
+                test.Operator = HeaderSkipTestFileOperator.Equal;
-
-                    case "and":
-                        test.Type = HeaderSkipTest.And;
-                        break;
-
-                    case "file":
-                        test.Type = HeaderSkipTest.File;
-                        break;
-
-                    default:
-                        return null;
-                }
 
                 // Now populate all the parts that we can
                 if (xtr.GetAttribute("offset") != null)

SabreTools.Skippers/SkipperFiles/Atari7800.cs

@@ -11,17 +11,15 @@ namespace SabreTools.Skippers.SkipperFiles
         public Atari7800()
         {
             // Create tests
-            var rule1Test1 = new SkipperTest
+            var rule1Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x01,
                 Value = new byte[] { 0x41, 0x54, 0x41, 0x52, 0x49, 0x37, 0x38, 0x30, 0x30 },
                 Result = true,
             };
 
-            var rule2Test1 = new SkipperTest
+            var rule2Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x64,
                 Value = new byte[] { 0x41, 0x43, 0x54, 0x55, 0x41, 0x4C, 0x20, 0x43, 0x41, 0x52, 0x54, 0x20, 0x44, 0x41, 0x54, 0x41, 0x20, 0x53, 0x54, 0x41, 0x52, 0x54, 0x53, 0x20, 0x48, 0x45, 0x52, 0x45 },
                 Result = true,

SabreTools.Skippers/SkipperFiles/AtariLynx.cs

@@ -11,17 +11,15 @@ namespace SabreTools.Skippers.SkipperFiles
         public AtariLynx()
         {
             // Create tests
-            var rule1Test1 = new SkipperTest
+            var rule1Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x4C, 0x59, 0x4E, 0x58 },
                 Result = true,
             };
 
-            var rule2Test1 = new SkipperTest
+            var rule2Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x06,
                 Value = new byte[] { 0x42, 0x53, 0x39 },
                 Result = true,

SabreTools.Skippers/SkipperFiles/CommodorePSID.cs

@@ -11,41 +11,36 @@ namespace SabreTools.Skippers.SkipperFiles
         public CommodorePSID()
         {
             // Create tests
-            var rule1Test1 = new SkipperTest
+            var rule1Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x50, 0x53, 0x49, 0x44, 0x00, 0x01, 0x00, 0x76 },
                 Result = true,
             };
 
-            var rule2Test1 = new SkipperTest
+            var rule2Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x50, 0x53, 0x49, 0x44, 0x00, 0x03, 0x00, 0x7c },
                 Result = true,
             };
 
-            var rule3Test1 = new SkipperTest
+            var rule3Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x50, 0x53, 0x49, 0x44, 0x00, 0x02, 0x00, 0x7c },
                 Result = true,
             };
 
-            var rule4Test1 = new SkipperTest
+            var rule4Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x50, 0x53, 0x49, 0x44, 0x00, 0x01, 0x00, 0x7c },
                 Result = true,
             };
 
-            var rule5Test1 = new SkipperTest
+            var rule5Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x52, 0x53, 0x49, 0x44, 0x00, 0x02, 0x00, 0x7c },
                 Result = true,

SabreTools.Skippers/SkipperFiles/NECPCEngine.cs

@@ -11,9 +11,8 @@ namespace SabreTools.Skippers.SkipperFiles
         public NECPCEngine()
         {
             // Create tests
-            var rule1Test1 = new SkipperTest
+            var rule1Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xBB, 0x02 },
                 Result = true,

SabreTools.Skippers/SkipperFiles/Nintendo64.cs

@@ -11,25 +11,22 @@ namespace SabreTools.Skippers.SkipperFiles
         public Nintendo64()
         {
             // Create tests
-            var rule1Test1 = new SkipperTest
+            var rule1Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x80, 0x37, 0x12, 0x40 },
                 Result = true,
             };
 
-            var rule2Test1 = new SkipperTest
+            var rule2Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x37, 0x80, 0x40, 0x12 },
                 Result = true,
             };
 
-            var rule3Test1 = new SkipperTest
+            var rule3Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x40, 0x12, 0x37, 0x80 },
                 Result = true,

SabreTools.Skippers/SkipperFiles/NintendoEntertainmentSystem.cs

@@ -11,9 +11,8 @@ namespace SabreTools.Skippers.SkipperFiles
         public NintendoEntertainmentSystem()
         {
             // Create tests
-            var rule1Test1 = new SkipperTest
+            var rule1Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x4E, 0x45, 0x53, 0x1A },
                 Result = true,

SabreTools.Skippers/SkipperFiles/NintendoFamicomDiskSystem.cs

@@ -11,33 +11,29 @@ namespace SabreTools.Skippers.SkipperFiles
         public NintendoFamicomDiskSystem()
         {
             // Create tests
-            var rule1Test1 = new SkipperTest
+            var rule1Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x46, 0x44, 0x53, 0x1A, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                 Result = true,
             };
 
-            var rule2Test1 = new SkipperTest
+            var rule2Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x46, 0x44, 0x53, 0x1A, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                 Result = true,
             };
 
-            var rule3Test1 = new SkipperTest
+            var rule3Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x46, 0x44, 0x53, 0x1A, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                 Result = true,
             };
 
-            var rule4Test1 = new SkipperTest
+            var rule4Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x46, 0x44, 0x53, 0x1A, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                 Result = true,

SabreTools.Skippers/SkipperFiles/SuperFamicomSPC.cs

@@ -11,9 +11,8 @@ namespace SabreTools.Skippers.SkipperFiles
         public SuperFamicomSPC()
         {
             // Create tests
-            var rule1Test1 = new SkipperTest
+            var rule1Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x00,
                 Value = new byte[] { 0x53, 0x4E, 0x45, 0x53, 0x2D, 0x53, 0x50, 0x43 },
                 Result = true,

SabreTools.Skippers/SkipperFiles/SuperNintendoEntertainmentSystem.cs

@@ -11,25 +11,22 @@ namespace SabreTools.Skippers.SkipperFiles
         public SuperNintendoEntertainmentSystem()
         {
             // Create tests
-            var rule1Test1 = new SkipperTest
+            var rule1Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x16,
                 Value = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
                 Result = true,
             };
 
-            var rule2Test1 = new SkipperTest
+            var rule2Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x16,
                 Value = new byte[] { 0xAA, 0xBB, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 },
                 Result = true,
             };
 
-            var rule3Test1 = new SkipperTest
+            var rule3Test1 = new DataSkipperTest
             {
-                Type = HeaderSkipTest.Data,
                 Offset = 0x16,
                 Value = new byte[] { 0x53, 0x55, 0x50, 0x45, 0x52, 0x55, 0x46, 0x4F },
                 Result = true,

SabreTools.Skippers/SkipperRule.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Xml.Serialization;
 
 using SabreTools.Logging;
 
@@ -13,26 +14,36 @@ namespace SabreTools.Skippers
         /// <summary>
         /// Starting offset for applying rule
         /// </summary>
+        [XmlAttribute("start_offset")]
         public long? StartOffset { get; set; } // null is EOF
 
         /// <summary>
         /// Ending offset for applying rule
         /// </summary>
+        [XmlAttribute("end_offset")]
         public long? EndOffset { get; set; } // null if EOF
 
         /// <summary>
         /// Byte manipulation operation
         /// </summary>
+        [XmlAttribute("operation")]
         public HeaderSkipOperation Operation { get; set; }
 
         /// <summary>
         /// List of matching tests in a rule
         /// </summary>
+        [XmlArray]
+        [XmlArrayItem("data")]
+        [XmlArrayItem("or")]
+        [XmlArrayItem("xor")]
+        [XmlArrayItem("and")]
+        [XmlArrayItem("file")]
         public List<SkipperTest> Tests { get; set; }
 
         /// <summary>
         /// Filename the skipper rule lives in
         /// </summary>
+        [XmlIgnore]
         public string SourceFile { get; set; }
 
         #endregion

SabreTools.Skippers/SkipperTest.cs

@@ -1,49 +1,52 @@
 using System;
 using System.IO;
+using System.Xml;
+using System.Xml.Serialization;
 
 namespace SabreTools.Skippers
 {
     /// <summary>
     /// Individual test that applies to a SkipperRule
     /// </summary>
-    public class SkipperTest
+    public abstract class SkipperTest
     {
         #region Fields
 
-        /// <summary>
-        /// Type of test to be run
-        /// </summary>
-        public HeaderSkipTest Type { get; set; }
-
         /// <summary>
         /// File offset to run the test
         /// </summary>
         /// <remarks>null is EOF</remarks>
+        [XmlAttribute("offset")]
         public long? Offset { get; set; }
 
         /// <summary>
         /// Static value to be checked at the offset
         /// </summary>
+        [XmlAttribute("value")]
         public byte[] Value { get; set; }
 
         /// <summary>
         /// Determines whether a pass or failure is expected
         /// </summary>
+        [XmlAttribute("result")]
         public bool Result { get; set; }
 
         /// <summary>
         /// Byte mask to be applied to the tested bytes
         /// </summary>
+        [XmlAttribute("mask")]
         public byte[] Mask { get; set; }
 
         /// <summary>
         /// Expected size of the input byte array, used with the Operator
         /// </summary>
+        [XmlAttribute("size")]
         public long? Size { get; set; } // null is PO2, "power of 2" filesize
 
         /// <summary>
         /// Expected range value for the input byte array size, used with Size
         /// </summary>
+        [XmlAttribute("operator")]
         public HeaderSkipTestFileOperator Operator { get; set; }
 
         #endregion
@@ -53,27 +56,50 @@ namespace SabreTools.Skippers
         /// </summary>
         /// <param name="input">Stream to check rule against</param>
         /// <remarks>The Stream is assumed to be in the proper position for a given test</remarks>
-        public bool Passes(Stream input)
+        public abstract bool Passes(Stream input);
-        {
-            return Type switch
-            {
-                HeaderSkipTest.And => CheckAnd(input),
-                HeaderSkipTest.Data => CheckData(input),
-                HeaderSkipTest.File => CheckFile(input),
-                HeaderSkipTest.Or => CheckOr(input),
-                HeaderSkipTest.Xor => CheckXor(input),
-                _ => true,
-            };
-        }
 
         #region Checking Helpers
 
         /// <summary>
-        /// Run an And test against an input stream
+        /// Seek an input stream based on the test value
         /// </summary>
-        /// <param name="input">Stream to check rule against</param>
+        /// <param name="input">Stream to seek</param>
-        /// <returns>True if the stream passed, false otherwise</returns>
+        /// <returns>True if the stream could seek, false on error</returns>
-        private bool CheckAnd(Stream input)
+        protected bool Seek(Stream input)
+        {
+            try
+            {
+                // Null offset means EOF
+                if (Offset == null)
+                    input.Seek(0, SeekOrigin.End);
+
+                // Positive offset means from beginning
+                else if (Offset >= 0 && Offset <= input.Length)
+                    input.Seek(Offset.Value, SeekOrigin.Begin);
+
+                // Negative offset means from end
+                else if (Offset < 0 && Math.Abs(Offset.Value) <= input.Length)
+                    input.Seek(Offset.Value, SeekOrigin.End);
+
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        #endregion
+    }
+
+    /// <summary>
+    /// Skipper test using AND
+    /// </summary>
+    [XmlRoot("and")]
+    public class AndSkipperTest : SkipperTest
+    {
+        /// <inheritdoc/>
+        public override bool Passes(Stream input)
         {
             // First seek to the correct position
             Seek(input);
@@ -109,13 +135,16 @@ namespace SabreTools.Skippers
             // Return if the expected and actual results match
             return result == Result;
         }
+    }
 
-        /// <summary>
+    /// <summary>
-        /// Run a Data test against an input stream
+    /// Skipper test using DATA
-        /// </summary>
+    /// </summary>
-        /// <param name="input">Stream to check rule against</param>
+    [XmlRoot("data")]
-        /// <returns>True if the stream passed, false otherwise</returns>
+    public class DataSkipperTest : SkipperTest
-        private bool CheckData(Stream input)
+    {
+        /// <inheritdoc/>
+        public override bool Passes(Stream input)
         {
             // First seek to the correct position
             if (!Seek(input))
@@ -143,13 +172,16 @@ namespace SabreTools.Skippers
             // Return if the expected and actual results match
             return result == Result;
         }
+    }
 
-        /// <summary>
+    /// <summary>
-        /// Run a File test against an input stream
+    /// Skipper test using FILE
-        /// </summary>
+    /// </summary>
-        /// <param name="input">Stream to check rule against</param>
+    [XmlRoot("file")]
-        /// <returns>True if the stream passed, false otherwise</returns>
+    public class FileSkipperTest : SkipperTest
-        private bool CheckFile(Stream input)
+    {
+        /// <inheritdoc/>
+        public override bool Passes(Stream input)
         {
             // First get the file size from stream
             long size = input.Length;
@@ -177,13 +209,16 @@ namespace SabreTools.Skippers
             // Return if the expected and actual results match
             return result == Result;
         }
+    }
 
-        /// <summary>
+    /// <summary>
-        /// Run an Or test against an input stream
+    /// Skipper test using OR
-        /// </summary>
+    /// </summary>
-        /// <param name="input">Stream to check rule against</param>
+    [XmlRoot("or")]
-        /// <returns>True if the stream passed, false otherwise</returns>
+    public class OrSkipperTest : SkipperTest
-        private bool CheckOr(Stream input)
+    {
+        /// <inheritdoc/>
+        public override bool Passes(Stream input)
         {
             // First seek to the correct position
             Seek(input);
@@ -219,13 +254,16 @@ namespace SabreTools.Skippers
             // Return if the expected and actual results match
             return result == Result;
         }
+    }
 
-        /// <summary>
+    /// <summary>
-        /// Run an Xor test against an input stream
+    /// Skipper test using XOR
-        /// </summary>
+    /// </summary>
-        /// <param name="input">Stream to check rule against</param>
+    [XmlRoot("xor")]
-        /// <returns>True if the stream passed, false otherwise</returns>
+    public class XorSkipperTest : SkipperTest
-        private bool CheckXor(Stream input)
+    {
+        /// <inheritdoc/>
+        public override bool Passes(Stream input)
         {
             // First seek to the correct position
             Seek(input);
@@ -261,36 +299,5 @@ namespace SabreTools.Skippers
             // Return if the expected and actual results match
             return result == Result;
         }
-
-        /// <summary>
-        /// Seek an input stream based on the test value
-        /// </summary>
-        /// <param name="input">Stream to seek</param>
-        /// <returns>True if the stream could seek, false on error</returns>
-        private bool Seek(Stream input)
-        {
-            try
-            {
-                // Null offset means EOF
-                if (Offset == null)
-                    input.Seek(0, SeekOrigin.End);
-
-                // Positive offset means from beginning
-                else if (Offset >= 0 && Offset <= input.Length)
-                    input.Seek(Offset.Value, SeekOrigin.Begin);
-
-                // Negative offset means from end
-                else if (Offset < 0 && Math.Abs(Offset.Value) <= input.Length)
-                    input.Seek(Offset.Value, SeekOrigin.End);
-
-                return true;
-            }
-            catch
-            {
-                return false;
-            }
-        }
-
-        #endregion
     }
 }