Added support for Atari ST executable.

README.md

@@ -8,5 +8,6 @@ It is also accompanied by a command line application as an example of usage.
 
 Supported executable formats
 ============================
+* Atari ST executable
 * MZ (aka DOS relocatable executable)
 * NE (Microsoft New Executable)

exeinfo/Program.cs

@@ -51,6 +51,7 @@ namespace exeinfo
 
             MZ mzExe = new MZ(exeFs);
             NE neExe = new NE(exeFs);
+            AtariST stExe = new AtariST(exeFs);
 
             if (mzExe.IsMZ)
             {
@@ -110,6 +111,12 @@ namespace exeinfo
                 }
             }
 
+            if (stExe.IsAtariST)
+			{
+				recognized = true;
+                Console.Write(stExe.GetInfo());
+			}
+
 			if (!recognized)
                 Console.WriteLine("Executable format not recognized");
         }

libexeinfo/AtariST/AtariST.cs

@@ -0,0 +1,106 @@
+//
+// AtariST.cs
+//
+// Author:
+//       Natalia Portillo <claunia@claunia.com>
+//
+// Copyright (c) 2017 Copyright © Claunia.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace libexeinfo
+{
+	/// <summary>
+	/// Represents an Atari ST executable
+	/// </summary>
+	public partial class AtariST
+    {
+		/// <summary>
+		/// The <see cref="FileStream"/> that contains the executable represented by this instance
+		/// </summary>
+		public readonly FileStream BaseStream;
+		/// <summary>
+		/// Header for this executable
+		/// </summary>
+		public readonly AtariHeader Header;
+		/// <summary>
+		/// If true this instance correctly represents an Atari ST executable
+		/// </summary>
+        public readonly bool IsAtariST;
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="T:libexeinfo.AtariST"/> class.
+		/// </summary>
+		/// <param name="path">Executable path.</param>
+		public AtariST(string path)
+		{
+			byte[] buffer = new byte[Marshal.SizeOf(typeof(AtariHeader))];
+
+			BaseStream = File.Open(path, FileMode.Open, FileAccess.Read);
+			BaseStream.Position = 0;
+			BaseStream.Read(buffer, 0, buffer.Length);
+            Header = BigEndianMarshal.ByteArrayToStructureBigEndian<AtariHeader>(buffer);
+			IsAtariST = Header.signature == Signature;
+		}
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="T:libexeinfo.AtariST"/> class.
+		/// </summary>
+		/// <param name="stream">Stream containing the executable.</param>
+		public AtariST(FileStream stream)
+		{
+			byte[] buffer = new byte[Marshal.SizeOf(typeof(AtariHeader))];
+
+			BaseStream = stream;
+			BaseStream.Position = 0;
+			BaseStream.Read(buffer, 0, buffer.Length);
+			Header = BigEndianMarshal.ByteArrayToStructureBigEndian<AtariHeader>(buffer);
+			IsAtariST = Header.signature == Signature;
+		}
+
+		/// <summary>
+		/// Identifies if the specified executable is a Atari ST executable
+		/// </summary>
+		/// <returns><c>true</c> if the specified executable is a Atari ST executable, <c>false</c> otherwise.</returns>
+		/// <param name="path">Executable path.</param>
+		public static bool Identify(string path)
+		{
+			FileStream exeFs = File.Open(path, FileMode.Open, FileAccess.Read);
+			return Identify(exeFs);
+		}
+
+		/// <summary>
+		/// Identifies if the specified executable is a Atari ST executable
+		/// </summary>
+		/// <returns><c>true</c> if the specified executable is a Atari ST executable, <c>false</c> otherwise.</returns>
+		/// <param name="stream">Stream containing the executable.</param>
+		public static bool Identify(FileStream stream)
+		{
+			byte[] buffer = new byte[Marshal.SizeOf(typeof(AtariHeader))];
+
+			stream.Position = 0;
+			stream.Read(buffer, 0, buffer.Length);
+			AtariHeader hdr = BigEndianMarshal.ByteArrayToStructureBigEndian<AtariHeader>(buffer);
+
+			return hdr.signature == Signature;
+		}
+	}
+}

libexeinfo/AtariST/Consts.cs

@@ -0,0 +1,33 @@
+//
+// Consts.cs
+//
+// Author:
+//       Natalia Portillo <claunia@claunia.com>
+//
+// Copyright (c) 2017 Copyright © Claunia.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+namespace libexeinfo
+{
+	public partial class AtariST
+	{
+		public const ushort Signature = 0x601A;
+	}
+}

libexeinfo/AtariST/Info.cs

@@ -0,0 +1,58 @@
+//
+// Info.cs
+//
+// Author:
+//       Natalia Portillo <claunia@claunia.com>
+//
+// Copyright (c) 2017 Copyright © Claunia.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System.Text;
+
+namespace libexeinfo
+{
+    public partial class AtariST
+	{
+		/// <summary>
+		/// Gets a string with human readable information for a given Atari ST header
+		/// </summary>
+		/// <returns>Human readable information for given Atari ST header.</returns>
+		/// <param name="header">Atari ST executable header.</param>
+		public static string GetInfo(AtariHeader header)
+		{
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("Atari ST executable:");
+            sb.AppendFormat("\t{0} bytes in text segment", header.text_len).AppendLine();
+            sb.AppendFormat("\t{0} bytes in data segment", header.data_len).AppendLine();
+            sb.AppendFormat("\t{0} bytes in BSS segment", header.bss_len).AppendLine();
+            sb.AppendFormat("\t{0} bytes in symbol table", header.symb_len).AppendLine();
+			return sb.ToString();
+		}
+
+		/// <summary>
+		/// Gets a string with human readable information for the Atari ST executable represented by this instance
+		/// </summary>
+		/// <returns>Human readable information for this instance.</returns>
+		public string GetInfo()
+        {
+            return GetInfo(Header);
+        }
+	}
+}

libexeinfo/AtariST/Structs.cs

@@ -0,0 +1,46 @@
+//
+// Structs.cs
+//
+// Author:
+//       Natalia Portillo <claunia@claunia.com>
+//
+// Copyright (c) 2017 Copyright © Claunia.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Runtime.InteropServices;
+
+namespace libexeinfo
+{
+    public partial class AtariST
+    {
+		[StructLayout(LayoutKind.Sequential, Pack = 1)]
+		public struct AtariHeader
+		{
+            public ushort signature;
+            public uint text_len;
+            public uint data_len;
+            public uint bss_len;
+            public uint symb_len;
+            public uint reserved;
+            public uint flags;
+            public ushort absflags;
+		}
+    }
+}

libexeinfo/BigEndianMarshal.cs

@@ -0,0 +1,123 @@
+//
+// BigEndianMarshal.cs
+//
+// Author:
+//       Natalia Portillo <claunia@claunia.com>
+//
+// Copyright (c) 2017 Copyright © Claunia.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace libexeinfo
+{
+    public static class BigEndianMarshal
+    {
+        /// <summary>
+        /// Marshals a big endian structure from a byte array.
+        /// Nested structures are still marshalled as little endian.
+        /// </summary>
+        /// <returns>The structure.</returns>
+        /// <param name="bytes">Byte array.</param>
+        /// <typeparam name="T">Structure type.</typeparam>
+        public static T ByteArrayToStructureBigEndian<T>(byte[] bytes) where T : struct
+        {
+            GCHandle ptr = GCHandle.Alloc(bytes, GCHandleType.Pinned);
+            T str = (T)Marshal.PtrToStructure(ptr.AddrOfPinnedObject(), typeof(T));
+            ptr.Free();
+            return SwapStructureMembersEndian(str);
+        }
+
+        /// <summary>
+        /// Swaps endian of structure members that correspond to numerical types.
+        /// Does not traverse nested structures.
+        /// </summary>
+        /// <returns>The structure with its members endian swapped.</returns>
+        /// <param name="str">The structure.</param>
+        /// <typeparam name="T">Structure type.</typeparam>
+        public static T SwapStructureMembersEndian<T>(T str) where T : struct
+        {
+            Type t = str.GetType();
+            FieldInfo[] fieldInfo = t.GetFields();
+            foreach (FieldInfo fi in fieldInfo)
+            {
+                if (fi.FieldType == typeof(short))
+                {
+                    short int16 = (short)fi.GetValue(str);
+                    byte[] int16_b = BitConverter.GetBytes(int16);
+                    byte[] int16_r = int16_b.Reverse().ToArray();
+                    fi.SetValueDirect(__makeref(str), BitConverter.ToInt16(int16_r, 0));
+                }
+                else if (fi.FieldType == typeof(int))
+                {
+                    int int32 = (int)fi.GetValue(str);
+                    byte[] int32_b = BitConverter.GetBytes(int32);
+                    byte[] int32_r = int32_b.Reverse().ToArray();
+                    fi.SetValueDirect(__makeref(str), BitConverter.ToInt32(int32_r, 0));
+                }
+                else if (fi.FieldType == typeof(long))
+                {
+                    long int64 = (long)fi.GetValue(str);
+                    byte[] int64_b = BitConverter.GetBytes(int64);
+                    byte[] int64_r = int64_b.Reverse().ToArray();
+                    fi.SetValueDirect(__makeref(str), BitConverter.ToInt64(int64_r, 0));
+                }
+                else if (fi.FieldType == typeof(ushort))
+                {
+                    ushort uint16 = (ushort)fi.GetValue(str);
+                    byte[] uint16_b = BitConverter.GetBytes(uint16);
+                    byte[] uint16_r = uint16_b.Reverse().ToArray();
+                    fi.SetValueDirect(__makeref(str), BitConverter.ToInt16(uint16_r, 0));
+                }
+                else if (fi.FieldType == typeof(uint))
+                {
+                    uint uint32 = (uint)fi.GetValue(str);
+                    byte[] uint32_b = BitConverter.GetBytes(uint32);
+                    byte[] uint32_r = uint32_b.Reverse().ToArray();
+                    fi.SetValueDirect(__makeref(str), BitConverter.ToInt32(uint32_r, 0));
+                }
+                else if (fi.FieldType == typeof(ulong))
+                {
+                    ulong uint64 = (ulong)fi.GetValue(str);
+                    byte[] uint64_b = BitConverter.GetBytes(uint64);
+                    byte[] uint64_r = uint64_b.Reverse().ToArray();
+                    fi.SetValueDirect(__makeref(str), BitConverter.ToInt64(uint64_r, 0));
+                }
+                else if (fi.FieldType == typeof(float))
+                {
+                    float flt = (float)fi.GetValue(str);
+                    byte[] flt_b = BitConverter.GetBytes(flt);
+                    byte[] flt_r = flt_b.Reverse().ToArray();
+                    fi.SetValueDirect(__makeref(str), BitConverter.ToSingle(flt_r, 0));
+                }
+                else if (fi.FieldType == typeof(double))
+                {
+                    double dbl = (double)fi.GetValue(str);
+                    byte[] dbl_b = BitConverter.GetBytes(dbl);
+                    byte[] dbl_r = dbl_b.Reverse().ToArray();
+                    fi.SetValueDirect(__makeref(str), BitConverter.ToDouble(dbl_r, 0));
+                }
+            }
+            return str;
+        }
+    }
+}

libexeinfo/libexeinfo.csproj

@@ -54,6 +54,11 @@
     <Compile Include="NE\Version.cs" />
     <Compile Include="MZ\MZ.cs" />
     <Compile Include="NE\NE.cs" />
+    <Compile Include="BigEndianMarshal.cs" />
+    <Compile Include="AtariST\Structs.cs" />
+    <Compile Include="AtariST\Consts.cs" />
+    <Compile Include="AtariST\AtariST.cs" />
+    <Compile Include="AtariST\Info.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
@@ -67,6 +72,7 @@
   <ItemGroup>
     <Folder Include="MZ\" />
     <Folder Include="NE\" />
+    <Folder Include="AtariST\" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <Import Project="..\packages\NuGet.Build.Packaging.0.1.276\build\NuGet.Build.Packaging.targets" Condition="Exists('..\packages\NuGet.Build.Packaging.0.1.276\build\NuGet.Build.Packaging.targets')" />