anchor.diff:              let regex = new Regex(pattern, RegexOptions.Multiline)
               let matches = regex.Matches(fileText)
               let matchesList = matches |> Seq.cast |> Seq.toList
  -            let rec addInfo list (acc : (string * int * Match) list) =
  +            let rec addInfo list (acc : (string * int * int * Match) list) =
                   match list with
                   | (hd : Match) :: tl ->
  -                    let offset = (hd.Captures.[0].Index)
  -                    let lineNumber = lineNumberLookup lineEndings offset
  -                    addInfo tl ((fileName, lineNumber, hd) :: acc)
  +                    let offsetFromFileStart = (hd.Captures.[0].Index)
  +                    let (lineNumber, lineStartOffset, lineEndOffset) = lineNumberLookup lineEndings offsetFromFileStart
  +                    let offsetFromLineStart = offsetFromFileStart - lineStartOffset
  +                    addInfo tl ((fileName, lineNumber, offsetFromLineStart, hd) :: acc)
                   | [] -> acc
               let newItems = addInfo matchesList []
               processFiles pattern tl (acc @ (List.rev newItems))
  
positive.code:         then NHol.parser.parse_type parseString |> ignore
          else failwith ("Unknow parse function: " + parseFunction)
          let msg = parseFunction + " successful."
          (fileName, lineNumber, regexMatch, parseString, msg) :: acc
      with
      | _ -> acc
          
  /// Process the matches to build a list of messages based on the condtions.
  let processConditions conditions info  : (string * int * Match * string * string) list =
      let rec processConditions (item : (string * int * Match)) conditions acc : (string * int * Match * string * string) list =
          match conditions with
          | condition :: tl ->
              let acc = condition item acc
              processConditions item tl acc
          | [] -> acc
      let rec prcessInfo (info : (string * int * Match) list) conditions acc : (string * int * Match * string * string) list =
          match info with
          | hd :: tl -> 
              let acc = processConditions hd conditions acc
  
negative.code:     |> toAbsolutePath 
      |> toFileList
  
  let printGroup (g : Group) =
      printfn "Group Index:        %d" g.Index 
      printfn "Group Length:       %d" g.Length 
      printfn "Group Success:      %b" g.Success 
      printfn "Group Value length: %d" g.Value.Length
      printfn "Group Value:        '%s'" g.Value 
      printfn "Group Capute count: %d" g.Captures.Count
  
  let printCapture (c : Capture) =
      printfn "Capture Index:        %d" c.Index 
      printfn "Capture Length:       %d" c.Length 
      printfn "Capture Value length: %d" c.Value.Length
      printfn "Capture Value:        '%s'" c.Value 
  
  let printMatch (m : Match) =
      printfn "Match Index:        %d" m.Index 
      printfn "Match Length:       %d" m.Length 
      printfn "Match Success:      %b" m.Success
      printfn "Match Value length: %d" m.Value.Length
      printfn "Match Value:        '%s'" m.Value 
      printfn "Match Capute count: %d" m.Captures.Count
      Seq.iter printCapture (Seq.cast m.Captures )
      printfn "Match Groups count: %d" m.Groups.Count
      Seq.iter printGroup (Seq.cast m.Groups)
      printfn "-----------------------------------------"
  
  /// Create a map with key as line number and value as line end offset from start of file.
  let lineEndingMap (fileName : string) : Map<int, (int * int)> = 
      // Don't add more match patterns as that will throw the line count off.
      // i.e. 2 match patterns will return 2x matches which will create 2x entries for line numbers 
      // and thus be incorrect.
  