mutating func cycle()

in Sources/Prototypes/PEG/PEGCore.swift [316:384]

• 53 lines of code
• 22 McCabe index (conditional complexity)

  mutating func cycle() {
    guard state == .processing else { return }
    defer { cycleCount += 1 }
    trace()

    switch fetch() {
    case .nop:
      self.nop()
    case .comment(let s):
      self.comment(s)
    case .consume(let n):
      self.consume(n)

    case .branch(let to):
      self.branch(to: to)
      // branches

    case .condBranch(let condition, let to):
      self.condBranch(condition, to: to)
      // branches

    case .save(let pc):
      self.save(pc)
    case .clear:
      self.clear()
    case .restore:
      self.restore() // branches

    case .push(let pc):
      self.push(pc)
    case .pop:
      guard let pc = self.pop() else {
        fatalError("figure out what to do here")
      }
      _ = pc
      self.advance()
    case .call(let pc):
      self.call(pc) // branches
    case .ret:
      self.ret() // branches

    case .assert(let e, let r):
      self.assert(e, r)

    case .assertPredicate(let p, let r):
      self.assertPredicate(p, r)

    case .match(let e):
      self.match(e)

    case .matchPredicate(let p):
      self.matchPredicate(p)

    case .matchHook(let h):
      self.matchHook(h)

    case .assertHook(let h, let r):
      self.assertHook(h, r)

    case .accept:
      self.accept()

    case .fail:
      self.fail() // branches

    case .abort(let s):
      self.abort(reason: s)
    }
  }