Extend Binary writer by input and output range, extend hex2bin example

Author: j123b567

IntelHex.csproj

@@ -18,6 +18,7 @@
     <WarningLevel>4</WarningLevel>
     <Externalconsole>true</Externalconsole>
     <PlatformTarget>x86</PlatformTarget>
+    <Commandlineparameters></Commandlineparameters>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
     <DebugType>full</DebugType>
@@ -43,6 +44,7 @@
     <Compile Include="IntelHex\Listeners\RangeDetector.cs" />
     <Compile Include="IntelHex\Listeners\BinWriter.cs" />
     <Compile Include="Program.cs" />
+    <Compile Include="Mono.Options\Options.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ItemGroup>

IntelHex/Listeners/BinWriter.cs

@@ -38,52 +38,67 @@ namespace IntelHex.Listeners
 	public class BinWriter : IDataListener
 	{
 
+		Region inputRegion;
+		Region outputRegion;
 
-		private Region outputRegion;
-		private Stream destination;
-		private byte[] buffer;
-		private MemoryRegions regions;
-		private uint maxAddress;
-		private bool minimize;
+		Stream destination;
+		byte[] buffer;
+		MemoryRegions writtenRegions;
+		Region written;
 
-		public BinWriter (Region outputRegion, Stream destination, bool minimize)
+
+		public BinWriter (Region inputRegion, Region outputRegion, byte fill, Stream destination)
 		{
+			this.inputRegion = inputRegion;
 			this.outputRegion = outputRegion;
 			this.destination = destination;
-			this.minimize = minimize;
-			this.buffer = Enumerable.Repeat((byte)0xFF, (int)outputRegion.GetLength ()).ToArray();
-			regions = new MemoryRegions ();
-			maxAddress = outputRegion.GetAddressStart ();
+
+			buffer = Enumerable.Repeat(fill, (int)outputRegion.GetLength ()).ToArray();
+			writtenRegions = new MemoryRegions ();
+			written = new Region (0, 0);
+
+			if (!this.outputRegion.HasExactStart ()) {
+				this.outputRegion.SetAddressStart (this.inputRegion.GetAddressStart ());
+			}
+			if (!this.outputRegion.HasExactEnd ()) {
+				this.outputRegion.SetAddressEnd ((uint)this.inputRegion.GetAddressEnd ());
+			}
 		}
 
 		public void Data (uint address, byte[] data)
 		{
-			regions.Add (address, (uint)data.Length);
-
-			if ((address >= outputRegion.GetAddressStart ()) && (address <= outputRegion.GetAddressEnd ())) {
-				int length = data.Length;
-				if ((address + length) > outputRegion.GetAddressEnd ()) {
-					length = (int)(outputRegion.GetAddressEnd () - address + 1);
-				}
-				Array.Copy (data, 0, buffer, (int)(address - outputRegion.GetAddressStart ()), length);
+			var current = new Region (address, (uint)data.Length);
+			current.Intersection (inputRegion);
+			current.Intersection (outputRegion);
 
-				if (maxAddress < (address + data.Length - 1)) {
-					maxAddress = address + (uint)data.Length - 1;
-				}
+			if (current.GetLength () > 0) {
+				long sourceIndex = current.GetAddressStart () - address;
+				long destinationIndex = address - outputRegion.GetAddressStart();
+				Array.Copy (data, (int)sourceIndex, buffer, (int)destinationIndex, current.GetLength());
+				writtenRegions.Add (current);
 			}
 		}
 
 		public void Eof ()
-		{       
-			if (!minimize) {
-				maxAddress = (uint)outputRegion.GetAddressEnd ();
+		{
+			UpdateWritten ();
+			destination.Write (buffer, 0, (int)written.GetLength());
+		}
+
+		void UpdateWritten ()
+		{
+			written = writtenRegions.GetFullRangeRegion ();
+			if (outputRegion.HasExactStart ()) {
+				written.SetAddressStart (outputRegion.GetAddressStart ());
+			}
+			if (outputRegion.HasExactEnd ()) {
+				written.SetAddressEnd ((uint)outputRegion.GetAddressEnd ());
 			}
-			destination.Write (buffer, 0, (int)(maxAddress - outputRegion.GetAddressStart () + 1));
 		}
 
-		public MemoryRegions GetMemoryRegions ()
+		public Region GetWrittenRegion ()
 		{
-			return regions;
+			return written;
 		}
 	}
 }

IntelHex/MemoryRegions.cs

@@ -38,6 +38,15 @@ public class MemoryRegions
 
 		private List<Region> regions = new List<Region> ();
 
+		/// <summary>
+		/// Add region to list
+		/// </summary>
+		/// <param name="region">Region.</param>
+		public void Add (Region region)
+		{
+			Add (region.GetAddressStart (), region.GetLength ());
+		}
+
 		/// <summary>
 		/// Add region to list
 		/// </summary>

IntelHex/Region.cs

@@ -34,22 +34,68 @@ namespace IntelHex
 	public class Region : IComparable
 	{
 
-		private uint addressStart;
-		private uint addressEnd;
+		uint addressStart;
+		uint addressEnd;
+		bool exactStart;
+		bool exactEnd;
+
+		public Region (string range)
+		{
+			string [] region = range == null ? new string [0] : range.Split (':');
+			if (region.Length == 0) {
+				exactStart = ReadAddress ("min", out addressStart);
+				exactEnd = ReadAddress ("max", out addressEnd);
+			} else if (region.Length == 1) {
+				exactStart = ReadAddress (region [0], out addressStart);
+				exactEnd = ReadAddress ("max", out addressEnd);
+			} else {
+				exactStart = ReadAddress (region [0], out addressStart);
+				exactEnd = ReadAddress (region [1] != null && region [1] != "" ? region [1] : "max", out addressEnd);
+			}
+		}
 
 		public Region (uint start, uint length)
 		{
-			this.addressStart = start;
-			this.addressEnd = start + length - 1;
+			addressStart = start;
+			addressEnd = start + length - 1;
+			exactStart = true;
+			exactEnd = true;
 		}
 
+		static bool ReadAddress (string s, out uint result)
+		{
+			if (s != null && s != "") {
+				if (s == "min") {
+					result = 0;
+					return false;
+				}
+				if (s == "max") {
+					result = 0xFFFFFFFF;
+					return false;
+				}
+				if (s.StartsWith ("0x", StringComparison.InvariantCultureIgnoreCase)) {
+					result = Convert.ToUInt32 (s.Substring (2), 16);
+				} else {
+					result = Convert.ToUInt32 (s);
+				}
+				return true;
+			}
+			result = 0;
+			return false;
+		}
+
+
 		/// <summary>
 		/// Get length of the region
 		/// </summary>
 		/// <returns>The length.</returns>
 		public uint GetLength ()
 		{
-			return addressEnd - addressStart + 1;
+			if (addressStart <= addressEnd) {
+				return addressEnd - addressStart + 1;
+			}
+
+			return 0;
 		}
 
 		/// <summary>
@@ -68,6 +114,7 @@ public long GetAddressEnd ()
 		public void SetAddressEnd (uint addressEnd)
 		{
 			this.addressEnd = addressEnd;
+			this.exactEnd = true;
 		}
 
 		/// <summary>
@@ -86,6 +133,7 @@ public uint GetAddressStart ()
 		public void SetAddressStart (uint addressStart)
 		{
 			this.addressStart = addressStart;
+			this.exactStart = true;
 		}
 
 		/// <summary>
@@ -97,6 +145,39 @@ public void IncLength (uint value)
 			addressEnd += value;
 		}
 
+
+		public bool HasExactStart ()
+		{
+			return exactStart;
+		}
+
+		public void SetExactStart (bool value)
+		{
+			exactStart = value;
+		}
+
+		/// <summary>
+		/// Hases the exact end.
+		/// </summary>
+		/// <returns>Wether the end address was exactly defined or calculated</returns>
+		public bool HasExactEnd ()
+		{
+			return exactEnd;
+		}
+
+		public void SetExactEnd (bool value)
+		{
+			exactEnd = value;
+		}
+
+		public void Intersection (Region other)
+		{
+			addressStart = addressStart > other.addressStart ? addressStart : other.addressStart;
+			addressEnd = addressEnd < other.addressEnd ? addressEnd : other.addressEnd;
+			//exactStart = exactStart | other.exactStart;
+			//exactEnd = exactEnd | other.exactEnd;
+		}
+
 		/// <summary>
 		/// Convert region to string
 		/// </summary>