0001    import Foundation
0002    
0003    func matchRange
Regex.swift:9
  return matchRange(string, regex: regex).location != NSNotFound
Regex.swift:76
        let r = matchRange(string, regex: regex)
Regex.swift:90
        let r = matchRange(string, regex: regex)
Tokenizer.swift:126
      let range = matchRange(text, regex: tokenPattern.pattern)
Tokenizer.swift:223
            let range = matchRange(text, regex: blockPattern)
 (string: String, regex: NSRegularExpression) -> NSRange {
0004      let sr = NSMakeRange(0, string.utf16.count)
0005      return regex.rangeOfFirstMatchInString(string, options: [], range: sr)
0006    }
0007    
0008    func matches
Parser.swift:470
  return context.tokens[1].type != .Colon || matches(match, regex: regex("\n"))
Parser.swift:503
        check: matches(literal, regex: headerPattern))
Parser.swift:516
  let check1 = matches(block, regex: invalidPattern)
Regex.swift:13
  if matches(options, regex: invalidOptionsPattern) {
Tokenizer.swift:137
                matches(text |> substringFromIndex(rangeEnd), regex: dashPattern)
Tokenizer.swift:206
            ) + (matches(text, regex: regex("^\(bBreak)")) && lead.endIndex > lead.startIndex
 (string: String, regex: NSRegularExpression) -> Bool {
0009      return matchRange(string, regex: regex).location != NSNotFound
0010    }
0011    
0012    func regex
Parser.swift:168
    let m = peekMatch(context) |> replace(regex("0o"), template: "")
Parser.swift:174
    let m = peekMatch(context) |> replace(regex("0x"), template: "")
Parser.swift:451
    let folded = m |> replace(regex("^[ \\t\\n]+|[ \\t\\n]+$"), template: "") |> foldFlow
Parser.swift:470
  return context.tokens[1].type != .Colon || matches(match, regex: regex("\n"))
Parser.swift:476
  let (body, trail) = block |> splitTrail(regex("\\n*$"))
Parser.swift:478
      |> replace(regex("^([^ \\t\\n].*)\\n(?=[^ \\t\\n])", options: "m"), template: "$1 ")
Parser.swift:480
            regex("^([^ \\t\\n].*)\\n(\\n+)(?![ \\t])", options: "m"), template: "$1$2")
Parser.swift:485
  let (lead, rest) = flow |> splitLead(regex("^[ \\t]+"))
Parser.swift:486
  let (body, trail) = rest |> splitTrail(regex("[ \\t]+$"))
Parser.swift:488
      |> replace(regex("^[ \\t]+|[ \\t]+$|\\\\\\n", options: "m"), template: "")
Parser.swift:489
      |> replace(regex("(^|.)\\n(?=.|$)"), template: "$1 ")
Parser.swift:490
      |> replace(regex("(.)\\n(\\n+)"), template: "$1$2")
Parser.swift:498
  let chomp = chomps[literal |> replace(regex("[^-+]"), template: "")] ?? 0
Parser.swift:499
  let indent = parseInt(literal |> replace(regex("[^1-9]"), template: ""), radix: 10)
Parser.swift:500
  let headerPattern = regex("^(\\||>)([1-9][-+]|[-+]?[1-9]?)( |$)")
Parser.swift:509
      |> splitLead(regex("^( *\\n)* {1,}(?! |\\n|$)"))
Parser.swift:511
      |> replace(regex("^( *\\n)*"), template: "")
Parser.swift:515
      regex("^( {0,\(effectiveIndent)}\\n)* {\(effectiveIndent + 1),}\\n")
Parser.swift:519
      |> replace(regex("^ {0,\(effectiveIndent)}"), template: "")
Parser.swift:520
      |> replace(regex("\\n {0,\(effectiveIndent)}"), template: "\n")
Parser.swift:522
          ? replace(regex("(\\n *)*$"), template: "")
Parser.swift:524
          ? replace(regex("(?=[^ ])(\\n *)*$"), template: "\n")
Parser.swift:537
  let (sign, str) = splitLead(regex("^[-+]"))(string)
Parser.swift:564
  return replace(regex("\\r\\n|\\r"), template: "\n")(s)
Parser.swift:572
  return replace(regex("''"), template: "'")(s)
Parser.swift:577
    |> replace(regex("\\\\([0abtnvfre \"\\/N_LP])"))
Parser.swift:579
    |> replace(regex("\\\\x([0-9A-Fa-f]{2})"))
Parser.swift:581
    |> replace(regex("\\\\u([0-9A-Fa-f]{4})"))
Parser.swift:583
    |> replace(regex("\\\\U([0-9A-Fa-f]{8})"))
Tokenizer.swift:69
let dashPattern = regex("^-([ \\t]+(?!#|\(bBreak))|(?=[ \\t\\n]))")
Tokenizer.swift:72
  (.YamlDirective, regex("^%YAML(?= )")),
Tokenizer.swift:73
  (.DocStart, regex("^---")),
Tokenizer.swift:74
  (.DocEnd, regex("^\\.\\.\\.")),
Tokenizer.swift:75
  (.Comment, regex("^#.*|^\(bBreak) *(#.*)?(?=\(bBreak)|$)")),
Tokenizer.swift:76
  (.Space, regex("^ +")),
Tokenizer.swift:77
  (.NewLine, regex("^\(bBreak) *")),
Tokenizer.swift:79
  (.Null, regex("^(null|Null|NULL|~)\(finish)")),
Tokenizer.swift:80
  (.True, regex("^(true|True|TRUE)\(finish)")),
Tokenizer.swift:81
  (.False, regex("^(false|False|FALSE)\(finish)")),
Tokenizer.swift:82
  (.InfinityP, regex("^\\+?\\.(inf|Inf|INF)\(finish)")),
Tokenizer.swift:83
  (.InfinityN, regex("^-\\.(inf|Inf|INF)\(finish)")),
Tokenizer.swift:84
  (.NaN, regex("^\\.(nan|NaN|NAN)\(finish)")),
Tokenizer.swift:85
  (.Int, regex("^[-+]?[0-9]+\(finish)")),
Tokenizer.swift:86
  (.IntOct, regex("^0o[0-7]+\(finish)")),
Tokenizer.swift:87
  (.IntHex, regex("^0x[0-9a-fA-F]+\(finish)")),
Tokenizer.swift:88
  (.IntSex, regex("^[0-9]{2}(:[0-9]{2})+\(finish)")),
Tokenizer.swift:89
  (.Double, regex("^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?\(finish)")),
Tokenizer.swift:90
  (.Anchor, regex("^&\\w+")),
Tokenizer.swift:91
  (.Alias, regex("^\\*\\w+")),
Tokenizer.swift:92
  (.Comma, regex("^,")),
Tokenizer.swift:93
  (.OpenSB, regex("^\\[")),
Tokenizer.swift:94
  (.CloseSB, regex("^\\]")),
Tokenizer.swift:95
  (.OpenCB, regex("^\\{")),
Tokenizer.swift:96
  (.CloseCB, regex("^\\}")),
Tokenizer.swift:97
  (.QuestionMark, regex("^\\?( +|(?=\(bBreak)))")),
Tokenizer.swift:98
  (.ColonFO, regex("^:(?!:)")),
Tokenizer.swift:99
  (.ColonFI, regex("^:(?!:)")),
Tokenizer.swift:100
  (.Literal, regex("^\\|.*")),
Tokenizer.swift:101
  (.Folded, regex("^>.*")),
Tokenizer.swift:102
  (.Reserved, regex("^[@`]")),
Tokenizer.swift:103
  (.StringDQ, regex("^\"([^\\\\\"]|\\\\(.|\(bBreak)))*\"")),
Tokenizer.swift:104
  (.StringSQ, regex("^'([^']|'')*'")),
Tokenizer.swift:105
  (.StringFO, regex("^\(plainOutPattern)(?=:([ \\t]|\(bBreak))|\(bBreak)|$)")),
Tokenizer.swift:106
  (.StringFI, regex("^\(plainInPattern)")),
Tokenizer.swift:112
      |> replace(regex("\\r"), template: "\\\\r")
Tokenizer.swift:113
      |> replace(regex("\\n"), template: "\\\\n")
Tokenizer.swift:114
      |> replace(regex("\""), template: "\\\\\"")
Tokenizer.swift:198
          let blockPattern = regex(("^(\(bBreak) *)*(\(bBreak)" +
Tokenizer.swift:203
              |> replace(regex("^\(bBreak)"), template: "")
Tokenizer.swift:204
              |> replace(regex("^ {0,\(lastIndent)}"), template: "")
Tokenizer.swift:205
              |> replace(regex("\(bBreak) {0,\(lastIndent)}"), template: "\n")
Tokenizer.swift:206
            ) + (matches(text, regex: regex("^\(bBreak)")) && lead.endIndex > lead.startIndex
Tokenizer.swift:216
          let blockPattern = regex(("^\(bBreak)( *| {\(indent),}" +
Tokenizer.swift:220
                |> replace(regex("^[ \\t]+|[ \\t]+$"), template: "")
Tokenizer.swift:229
                replace(regex("^\(bBreak)[ \\t]*|[ \\t]+$"), template: "")(s)
Tokenizer.swift:238
                |> replace(regex("^[ \\t]|[ \\t]$"), template: "")
 (pattern: String, options: String = "") -> NSRegularExpression! {
0013      if matches(options, regex: invalidOptionsPattern) {
0014        return nil
0015      }
0016    
0017      let opts = options.characters.reduce(NSRegularExpressionOptions()) { (acc, opt) -> NSRegularExpressionOptions in
0018        return NSRegularExpressionOptions(rawValue:acc.rawValue | (regexOptions[opt] ?? NSRegularExpressionOptions()).rawValue)
0019      }
0020      do {
0021        return try NSRegularExpression(pattern: pattern, options: opts)
0022      } catch _ {
0023        return nil
0024      }
0025    }
0026    
0027    let invalidOptionsPattern
Regex.swift:13
  if matches(options, regex: invalidOptionsPattern) {
 =
0028            try! NSRegularExpression(pattern: "[^ixsm]", options: [])
0029    
0030    let regexOptions
Regex.swift:18
    return NSRegularExpressionOptions(rawValue:acc.rawValue | (regexOptions[opt] ?? NSRegularExpressionOptions()).rawValue)
: [Character: NSRegularExpressionOptions] = [
0031      "i": .CaseInsensitive,
0032      "x": .AllowCommentsAndWhitespace,
0033      "s": .DotMatchesLineSeparators,
0034      "m": .AnchorsMatchLines
0035    ]
0036    
0037    func replace
Parser.swift:168
    let m = peekMatch(context) |> replace(regex("0o"), template: "")
Parser.swift:174
    let m = peekMatch(context) |> replace(regex("0x"), template: "")
Parser.swift:451
    let folded = m |> replace(regex("^[ \\t\\n]+|[ \\t\\n]+$"), template: "") |> foldFlow
Parser.swift:478
      |> replace(regex("^([^ \\t\\n].*)\\n(?=[^ \\t\\n])", options: "m"), template: "$1 ")
Parser.swift:479
      |> replace(
Parser.swift:488
      |> replace(regex("^[ \\t]+|[ \\t]+$|\\\\\\n", options: "m"), template: "")
Parser.swift:489
      |> replace(regex("(^|.)\\n(?=.|$)"), template: "$1 ")
Parser.swift:490
      |> replace(regex("(.)\\n(\\n+)"), template: "$1$2")
Parser.swift:498
  let chomp = chomps[literal |> replace(regex("[^-+]"), template: "")] ?? 0
Parser.swift:499
  let indent = parseInt(literal |> replace(regex("[^1-9]"), template: ""), radix: 10)
Parser.swift:511
      |> replace(regex("^( *\\n)*"), template: "")
Parser.swift:519
      |> replace(regex("^ {0,\(effectiveIndent)}"), template: "")
Parser.swift:520
      |> replace(regex("\\n {0,\(effectiveIndent)}"), template: "\n")
Parser.swift:522
          ? replace(regex("(\\n *)*$"), template: "")
Parser.swift:524
          ? replace(regex("(?=[^ ])(\\n *)*$"), template: "\n")
Parser.swift:564
  return replace(regex("\\r\\n|\\r"), template: "\n")(s)
Parser.swift:572
  return replace(regex("''"), template: "'")(s)
Tokenizer.swift:112
      |> replace(regex("\\r"), template: "\\\\r")
Tokenizer.swift:113
      |> replace(regex("\\n"), template: "\\\\n")
Tokenizer.swift:114
      |> replace(regex("\""), template: "\\\\\"")
Tokenizer.swift:203
              |> replace(regex("^\(bBreak)"), template: "")
Tokenizer.swift:204
              |> replace(regex("^ {0,\(lastIndent)}"), template: "")
Tokenizer.swift:205
              |> replace(regex("\(bBreak) {0,\(lastIndent)}"), template: "\n")
Tokenizer.swift:220
                |> replace(regex("^[ \\t]+|[ \\t]+$"), template: "")
Tokenizer.swift:229
                replace(regex("^\(bBreak)[ \\t]*|[ \\t]+$"), template: "")(s)
Tokenizer.swift:238
                |> replace(regex("^[ \\t]|[ \\t]$"), template: "")
 (regex: NSRegularExpression, template: String) -> String
0038        -> String {
0039          return { string in
0040            let s = NSMutableString(string: string)
0041            let range = NSMakeRange(0, string.utf16.count)
0042            regex.replaceMatchesInString(s, options: [], range: range,
0043                withTemplate: template)
0044            return s as String
0045          }
0046    }
0047    
0048    func replace
Parser.swift:577
    |> replace(regex("\\\\([0abtnvfre \"\\/N_LP])"))
Parser.swift:579
    |> replace(regex("\\\\x([0-9A-Fa-f]{2})"))
Parser.swift:581
    |> replace(regex("\\\\u([0-9A-Fa-f]{4})"))
Parser.swift:583
    |> replace(regex("\\\\U([0-9A-Fa-f]{8})"))
 (regex: NSRegularExpression, block: [String] -> String)
0049        -> String -> String {
0050          return { string in
0051            let s = NSMutableString(string: string)
0052            let range = NSMakeRange(0, string.utf16.count)
0053            var offset = 0
0054            regex.enumerateMatchesInString(string, options: [], range: range) {
0055              result, _, _ in
0056              if let result = result {
0057                  var captures = [String](count: result.numberOfRanges, repeatedValue: "")
0058                  for i in 0..<result.numberOfRanges {
0059                    if let r = result.rangeAtIndex(i).toRange() {
0060                      captures[i] = (string as NSString).substringWithRange(NSRange(r))
0061                    }
0062                  }
0063                  let replacement = block(captures)
0064                  let offR = NSMakeRange(result.range.location + offset, result.range.length)
0065                  offset += replacement.characters.count - result.range.length
0066                  s.replaceCharactersInRange(offR, withString: replacement)
0067              }
0068            }
0069            return s as String
0070          }
0071    }
0072    
0073    func splitLead
Parser.swift:485
  let (lead, rest) = flow |> splitLead(regex("^[ \\t]+"))
Parser.swift:509
      |> splitLead(regex("^( *\\n)* {1,}(?! |\\n|$)"))
Parser.swift:537
  let (sign, str) = splitLead(regex("^[-+]"))(string)
Tokenizer.swift:200
          let (lead, rest) = text |> splitLead(blockPattern)
 (regex: NSRegularExpression) -> String
0074        -> (String, String) {
0075          return { string in
0076            let r = matchRange(string, regex: regex)
0077            if r.location == NSNotFound {
0078              return ("", string)
0079            } else {
0080              let s = string as NSString
0081              let i = r.location + r.length
0082              return (s.substringToIndex(i), s.substringFromIndex(i))
0083            }
0084          }
0085    }
0086    
0087    func splitTrail
Parser.swift:476
  let (body, trail) = block |> splitTrail(regex("\\n*$"))
Parser.swift:486
  let (body, trail) = rest |> splitTrail(regex("[ \\t]+$"))
 (regex: NSRegularExpression) -> String
0088        -> (String, String) {
0089          return { string in
0090            let r = matchRange(string, regex: regex)
0091            if r.location == NSNotFound {
0092              return (string, "")
0093            } else {
0094              let s = string as NSString
0095              let i = r.location
0096              return (s.substringToIndex(i), s.substringFromIndex(i))
0097            }
0098          }
0099    }
0100    
0101    func substringWithRange
Tokenizer.swift:132
          let match = text |> substringWithRange(range)
Tokenizer.swift:163
          let match = text |> substringWithRange(range)
Tokenizer.swift:178
          let match = text |> substringWithRange(range)
Tokenizer.swift:187
          matchList.append(TokenMatch(tokenPattern.type, text |> substringWithRange(range)))
Tokenizer.swift:191
          matchList.append(TokenMatch(tokenPattern.type, text |> substringWithRange(range)))
Tokenizer.swift:194
          matchList.append(TokenMatch(tokenPattern.type, text |> substringWithRange(range)))
Tokenizer.swift:219
                |> substringWithRange(range)
Tokenizer.swift:227
            let s = text |> substringWithRange(range)
Tokenizer.swift:237
                |> substringWithRange(range)
Tokenizer.swift:245
          matchList.append(TokenMatch(tokenPattern.type, text |> substringWithRange(range)))
 (range: NSRange) -> String -> String {
0102      return { string in
0103        return (string as NSString).substringWithRange(range)
0104      }
0105    }
0106    
0107    func substringFromIndex
Tokenizer.swift:137
                matches(text |> substringFromIndex(rangeEnd), regex: dashPattern)
Tokenizer.swift:195
          text = text |> substringFromIndex(rangeEnd)
Tokenizer.swift:221
          text = text |> substringFromIndex(rangeEnd)
Tokenizer.swift:230
            text = text |> substringFromIndex(range.location + range.length)
Tokenizer.swift:247
        text = text |> substringFromIndex(rangeEnd)
 (index: Int) -> String -> String {
0108      return { string in
0109        return (string as NSString).substringFromIndex(index)
0110      }
0111    }
0112    
0113    func substringToIndex (index: Int) -> String -> String {
0114      return { string in
0115        return (string as NSString).substringToIndex(index)
0116      }
0117    }
0118