Create release candidate

Build.bat

@@ -1,2 +1,6 @@
 @echo off
-build\nant-0.91-alpha2\bin\nant.exe -f:"%cd%"\default.build %1
+build\nant-0.91-alpha2\bin\nant.exe -f:"%cd%"\default.build %1
+@echo.
+@echo %date%
+@echo %time%
+@echo.

ReleaseNotes.tmp

@@ -1,4 +1,7 @@
 Version [[version]]
+#376 protect buffer allocation in multithreaded environment (fix)
+
+Version 4.6.210 (rc - remove)
 #282 exclude by process (feature)
 #246 auto crash reports (feature)
 #329 address ArgumentOutOfRangeException (potentially related to #274) (fix for VS2015)

build/installer.build

@@ -21,6 +21,7 @@
         <include name="Gendarme.Rules.Maintainability.dll" />
         <include name="log4net.dll" />
         <include name="log4net.config" />
+        <include name="CrashReporter.NET.dll" />
       </fileset>
       <fileset basedir="${solution.folder}\bin\Release\x86" prefix="x86">
         <include name="OpenCover.Profiler.dll" />

main/OpenCover.Framework/Model/InstrumentationPoint.cs

@@ -13,6 +13,7 @@ namespace OpenCover.Framework.Model
     public class InstrumentationPoint
     {
         private static int _instrumentPoint;
+        private static object _addInstrumentPointSync = new object();
         private static readonly List<InstrumentationPoint> InstrumentPoints;
 
         static InstrumentationPoint()
@@ -114,10 +115,13 @@ public static bool AddVisitCount(uint spid, uint trackedMethodId, int sum = 1)
         /// </summary>
         public InstrumentationPoint()
         {
-            UniqueSequencePoint = (uint)Interlocked.Increment(ref _instrumentPoint);
-            InstrumentPoints.Add(this);
-            OrigSequencePoint = UniqueSequencePoint;
-        } 
+            lock (_addInstrumentPointSync)
+            {
+                UniqueSequencePoint = (uint)++_instrumentPoint;
+                InstrumentPoints.Add(this);
+                OrigSequencePoint = UniqueSequencePoint;
+            }
+        }
 
         /// <summary>
         /// Store the number of visits

main/OpenCover.Framework/Model/SequencePoint.cs

@@ -37,15 +37,18 @@ public class SequencePoint : InstrumentationPoint, IDocumentReference
         /// </summary>
         [XmlAttribute("ec")]
         public int EndColumn { get; set; }
-
+
+        /// <summary>
+        /// Count of merged branches
+        /// </summary>
         /// <summary>
         /// The number of branch exits
         /// </summary>
         [XmlAttribute("bec")]
         public int BranchExitsCount { get; set; }
 
         /// <summary>
-        /// The number of times the branch exists were visited
+        /// Visit count of merged branches 
         /// </summary>
         [XmlAttribute("bev")]
         public int BranchExitsVisit { get; set; }

main/OpenCover.Framework/OpenCover.Framework.csproj

@@ -145,6 +145,7 @@
     <Compile Include="Symbols\CecilSymbolManager.cs" />
     <Compile Include="Symbols\ISymbolManager.cs" />
     <Compile Include="Symbols\SymbolFolder.cs" />
+    <Compile Include="Utility\CodeCoverageStringTextSource.cs" />
     <Compile Include="Utility\IPerfCounters.cs" />
     <Compile Include="Utility\PerfCounters.cs" />
   </ItemGroup>

main/OpenCover.Framework/Utility/CodeCoverageStringTextSource.cs

@@ -0,0 +1,287 @@
+// Copyright (c) https://github.com/ddur
+// This code is distributed under MIT license
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+using OpenCover.Framework.Model;
+
+namespace OpenCover.Framework.Utility
+{
+	/// <summary>
+	/// FileType enum
+	/// </summary>
+	public enum FileType : byte {
+		/// <summary>
+		/// Unsupported file extension
+		/// </summary>
+		Unsupported,
+
+		/// <summary>
+		/// File extension is ".cs"
+		/// </summary>
+		CSharp,
+
+		/// <summary>
+		/// File extension is ".vb"
+		/// </summary>
+		VBasic
+	}
+    /// <summary>StringTextSource (ReadOnly)
+	/// <remarks>Line and column counting starts at 1.</remarks>
+    /// </summary>
+    public class CodeCoverageStringTextSource
+    {
+    	/// <summary>
+    	/// File Type by file name extension
+    	/// </summary>
+    	public FileType FileType = FileType.Unsupported;
+        private readonly string textSource;
+        private struct lineInfo {
+            public int Offset;
+            public int Length;
+        }
+        private readonly lineInfo[] lines;
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="source"></param>
+        public CodeCoverageStringTextSource(string source)
+        {
+            this.textSource = source;
+
+            lineInfo line;
+            var lineInfoList = new List<lineInfo>();
+            int offset = 0;
+            int counter = 0;
+            bool newLine = false;
+            bool cr = false;
+            bool lf = false;
+
+            foreach ( ushort ch in textSource ) {
+                switch (ch) {
+                    case 0xD:
+                        if (lf||cr) {
+                            newLine = true; // cr after cr|lf
+                        } else {
+                            cr = true; // cr found
+                        }
+                        break;
+                    case 0xA:
+                        if (lf) {
+                            newLine = true; // lf after lf
+                        } else {
+                            lf = true; // lf found
+                        }
+                        break;
+                    default:
+                        if (cr||lf) {
+                            newLine = true; // any non-line-end char after any line-end
+                        }
+                        break;
+                }
+                if (newLine) { // newLine detected - add line
+                    line = new lineInfo();
+                    line.Offset = offset;
+                    line.Length = counter - offset;
+                    lineInfoList.Add(line);
+                    offset = counter;
+                    cr = false;
+                    lf = false;
+                    newLine = false;
+                }
+                ++counter;
+            }
+
+            // Add last line
+            line = new lineInfo();
+            line.Offset = offset;
+            line.Length = counter - offset;
+            lineInfoList.Add(line);
+
+            // Store to readonly field
+            lines = lineInfoList.ToArray();
+        }
+
+        /// <summary>Return text/source using SequencePoint line/col info
+        /// </summary>
+        /// <param name="sp"></param>
+        /// <returns></returns>
+        public string GetText(SequencePoint sp) {
+            return this.GetText(sp.StartLine, sp.StartColumn, sp.EndLine, sp.EndColumn );
+        }
+
+        /// <summary>Return text at Line/Column/EndLine/EndColumn position
+        /// <remarks>Line and Column counting starts at 1.</remarks>
+        /// </summary>
+        /// <param name="Line"></param>
+        /// <param name="Column"></param>
+        /// <param name="EndLine"></param>
+        /// <param name="EndColumn"></param>
+        /// <returns></returns>
+        public string GetText(int Line, int Column, int EndLine, int EndColumn) {
+
+            var text = new StringBuilder();
+            string line;
+            bool argOutOfRange;
+
+            if (Line==EndLine) {
+
+                #region One-Line request
+                line = GetLine(Line);
+
+                //Debug.Assert(!(Column < 1), "Column < 1");
+                //Debug.Assert(!(Column > EndColumn), "Column > EndColumn");
+                //Debug.Assert(!(EndColumn > line.Length + 1), string.Format ("Single Line EndColumn({0}) > line.Length({1})",EndColumn, line.Length ));
+                //Debug.Assert(!(EndColumn > line.Length + 1), line);
+
+                argOutOfRange = Column < 1
+                    ||   Column > EndColumn
+                    ||   EndColumn > line.Length;
+                if (!argOutOfRange) {
+                    text.Append(line.Substring(Column-1,EndColumn-Column));
+                }
+                #endregion
+
+            } else if (Line<EndLine) {
+
+                #region Multi-line request
+
+                #region First line
+                line = GetLine(Line);
+
+                //Debug.Assert(!(Column < 1), "Column < 1");
+                //Debug.Assert(!(Column > line.Length), string.Format ("First MultiLine EndColumn({0}) > line.Length({1})",EndColumn, line.Length ));
+
+                argOutOfRange = Column < 1
+                    ||   Column > line.Length;
+                if (!argOutOfRange) {
+                    text.Append(line.Substring(Column-1));
+                }
+                #endregion
+
+                #region More than two lines
+                for ( int lineIndex = Line+1; lineIndex < EndLine; lineIndex++ ) {
+                    text.Append ( GetLine ( lineIndex ) );
+                }
+                #endregion
+
+                #region Last line
+                line = GetLine(EndLine);
+
+                //Debug.Assert(!(EndColumn < 1), "EndColumn < 1");
+                //Debug.Assert(!(EndColumn > line.Length), string.Format ("Last MultiLine EndColumn({0}) > line.Length({1})",EndColumn, line.Length ));
+
+                argOutOfRange = EndColumn < 1
+                    ||   EndColumn > line.Length;
+                if (!argOutOfRange) {
+                    text.Append(line.Substring(0,EndColumn));
+                }
+                #endregion
+
+                #endregion
+
+            } else {
+                //Debug.Fail("Line > EndLine");
+            }
+            return text.ToString();
+        }
+
+        /// <summary>
+        /// Return number of lines in source
+        /// </summary>
+        public int LinesCount {
+            get {
+                return lines.Length;
+            }
+        }
+
+        /// <summary>Return SequencePoint enumerated line
+        /// </summary>
+        /// <param name="LineNo"></param>
+        /// <returns></returns>
+        public string GetLine ( int LineNo ) {
+
+            string retString = String.Empty;
+
+            if ( LineNo > 0 && LineNo <= lines.Length ) {
+                lineInfo lineInfo = lines[LineNo-1];
+                retString = textSource.Substring(lineInfo.Offset, lineInfo.Length);
+            } else {
+                //Debug.Fail( "Line number out of range" );
+            }
+
+            return retString;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="ToIndent"></param>
+        /// <param name="TabSize"></param>
+        /// <returns></returns>
+        public static string IndentTabs ( string ToIndent, int TabSize ) {
+
+            string retString = ToIndent;
+            if ( ToIndent.Contains ( "\t" ) ) {
+                int counter = 0;
+                int remains = 0;
+                int repeat = 0;
+                char prevChar = char.MinValue;
+                var indented = new StringBuilder();
+                foreach ( char currChar in ToIndent ) {
+                    if ( currChar == '\t' ) {
+                        remains = counter % TabSize;
+                        repeat = remains == 0 ? TabSize : remains;
+                        indented.Append( ' ', repeat );
+                    } else {
+                        indented.Append ( currChar, 1 );
+                        if ( char.IsLowSurrogate(currChar) 
+                            && char.IsHighSurrogate(prevChar)
+                           ) { --counter; }
+                    }
+                    prevChar = currChar;
+                    ++counter;
+                }
+                retString = indented.ToString();
+            }
+            return retString;
+        }
+
+        /// <summary>
+        /// Get line-parsed source from file name
+        /// </summary>
+        /// <param name="filename"></param>
+        /// <returns></returns>
+		public static CodeCoverageStringTextSource GetSource(string filename) {
+
+			var retSource = (CodeCoverageStringTextSource)null;
+			try {
+				using (Stream stream = new FileStream(filename, FileMode.Open, FileAccess.Read)) {
+					try {
+						stream.Position = 0;
+						using (var reader = new StreamReader (stream, Encoding.Default, true)) {
+							retSource = new CodeCoverageStringTextSource(reader.ReadToEnd());
+							switch (Path.GetExtension(filename).ToLowerInvariant()) {
+								case ".cs":
+									retSource.FileType = FileType.CSharp;
+									break;
+								case ".vb":
+									retSource.FileType = FileType.VBasic;
+									break;
+								default:
+									retSource.FileType = FileType.Unsupported;
+									break;
+							}
+						}
+					} catch (Exception) {}
+				}
+			} catch (Exception) {}
+
+			return retSource;
+		}
+
+    }
+}

main/OpenCover.NugetPackage/OpenCover.nuspec

@@ -36,6 +36,7 @@
     <file src="main\bin\Release\OpenCover.Extensions.pdb" target="tools"/>
     <file src="main\bin\Release\log4net.config" target="tools"/>
     <file src="main\bin\Release\log4net.dll" target="tools"/>
+    <file src="main\bin\Release\CrashReporter.NET.dll" target="tools"/>
     <file src="main\OpenCover.Documentation\Usage.rtf" target="docs"/>
     <file src="ReleaseNotes.txt" target="docs" />
     <file src="main\bin\Release\OpenCover.MSBuild.dll" target="MSBuild"/>