EXC_BAD_ACCESS (code=2) when using NSNumberFormatter

Question

I'm having a problem, which I can't figure out for the life of me. I've searched the internet, trying to understand Swifts's EXC_BAD_ACCESS, but nothing seemed to help.

---

The following code is quite long, but most of the time the comments are all the information needed to understand the item of relevance.

I have a class CalculatorController, which contains the following relevant methods and properties:

import UIKit    

class CalculatorController: UIViewController {

    // the actual `@IBOutlet` which is never accessed directly
    @IBOutlet private weak var _mainDisplay: UILabel!
    
    // an instance of `MainDisplayMicroController`
    // holds a reference to `_mainDisplay`
    // is used to manipulate `_mainDisplay` in a controlled way
    private var mainDisplay: MainDisplayMicroController!
    
    override func viewDidLoad() {
        super.viewDidLoad()

        // connects `mainDisplay` with `_mainDisplay`
        mainDisplay = MainDisplayMicroController(label: _mainDisplay)
        
        // sets `_mainDisplay`'s `text` property to "0"
        mainDisplay.content = .Number(0)
    
        //...
    }

    //...
}

In order to manage _mainDisplay in a certain way, I have created a class MainDisplayMicroController, which on the one hand contains a reference to the the UILabel itself, and on the other hand contains methods and properties, which perform actions on the UILabel:

import UIKit

class MainDisplayMicroController {
    
    // used to express what `label.text` is currently showing
    private enum DisplayState {
        case ShowingNumber
        case ShowingConstant
        case ShowingErrorMessage
        case Unknown
    }

    // holds the current state of what `label.text` is showing
    private var state = DisplayState.Unknown

    // used to pass different types of values in and out of this class
    enum ContentType {
        case Number(Double)
        case Constant(String)
        case ErrorMessage(String)
        case Unknown(Any?)
    }

    // holds the reference to the label which is being manipulated/managed
    private var label: UILabel?

    // makes `label`'s `text` property directly accessible, as `label` is `private`
     var text: String? {
        get {
            return label?.text
        }
        set {
            label?.text = newValue
            removeLeadingZeros()
            transformToInteger()
        }
    }

    // a property to allow controlled retrieval and manipulation of `label.text`
    // uses `ContentType` to make clear what the information in `label.text` is/ is supposed to be
    var content: ContentType {
        get {
            switch state {
            case .ShowingNumber:
                if let string = text {
                    if let value = NSNumberFormatter().numberFromString(string)?.doubleValue {
                        return .Number(value)
                    }
                }
            case .ShowingConstant:
                if let symbol = text {
                    return .Constant(symbol)
                }
            case .ShowingErrorMessage:
                if let message = text {
                    return .ErrorMessage(message)
                }
            default:
                break
            }

            state = .Unknown
            return .Unknown(text)
        }
        set {
            switch newValue {
            case .Number(let value):
                text = "\(value)"
                state = .ShowingNumber
                removeLeadingZeros()
                transformToInteger()
            case .Constant(let symbol):
                text = symbol
                state = .ShowingConstant
            case .ErrorMessage(let message):
                text = message
                state = .ShowingErrorMessage
            case .Unknown(let thing):
                text = "Error: Passed unknown value: \(thing)"
                state = .ShowingErrorMessage
            }
        }
    }

    // removes the ".0" from `label.text`, if it is a whole number
    private func transformToInteger() {
        if state == .ShowingNumber {
            switch content {
            case .Number(let value):
                if round(value) == value {
                    var doubleString = "\(value)"

                    if doubleString.rangeOfString("e") == nil {
                        dropLast(doubleString)
                        dropLast(doubleString)
                    }

                    text = doubleString
                }
            default:
                break
            }
        }
    }

    // removes leading "0"s from `label.text` if they are redundant
    private func removeLeadingZeros() {
        if state == .ShowingNumber {
            switch content {
            case .Number(let displayedValue):
                content = .Number(displayedValue)
            default:
                break
            }
        }
    }

    //...
}

---

Now, when I run the code I get the following error:

From what I've read on EXC_BAD_ACCESS, the error often occurs when trying to call methods on released objects. I've tried using NSZombieto check the issue, but I didn't find anything (probably due to my incompetence when using NSZombie).

---

If I try to follow what is happening by logic, I come to following conclusion:

1. mainDisplay is set successfully in viewDidLoad()
2. mainDisplay.content is called
3. in the content's setter the switch-statement executes the .Number case
4. text and state are successfully set
5. removeLeadingZeros() is called
6. the switch-statement accesses content's getter
7. the switch-statement in content's getter executes the .ShowingNumber case
8. the if-statements resolve to true, finally trying to evaluate the NSNumberFormatter expression
9. the EXC_BAD_ACCESS occurs

---

Does anyone know why this is happening? Does it have to do with me manipulating an @IBOutlet in a different class?
Any help is greatly appreciated!

---

Here are links to the complete CalculatorController and MainDisplayMicroController.

---

Update #1:

As @abdullah suggested I have tried directing the NSNumberFormatter expression in to multiple expressions. I still get the error though:

---

Update #2:

I've removed all references and external classes, to make it as simple as possible, while maintaining the same functionality.
All of the methods and properties defined in MainDisplayMicroController have been moved to CalculatorModel.
These methods and properties now access the original @IBOutlet, not any reference to it.

But still when trying to run it I get EXC_BAD_ACCESS(code=2) at the same line of code.
I'm just super confused, as it can't have anything to do with weird references, or objects being released too soon anymore.

Here's the complete code for the new CalculatorController.

---

Update #3:

I've removed the NSNumberFormatter line, by changing it to:

Now I get the following error though:

I assume there's some fundamental problem with the code, so I'm scrapping it. But thanks for all the help, and attempts at figuring this out.

---

Update #4:

This is what I get when adding a breakpoint on throw for all exceptions:

Answer 1

I don't really see anything in that line that can cause a crash. I suggest you do the following:

1. Make a clean build (clean, nuke your derived data folder, then build) and see if the crash persists
2. If the crash persists, set a breakpoint on throw for all exceptions to see which operation in the callstack caused the crash, and take it from there

Answer 2

@WarrenBurton is on to something.

Take your line that crashes out of your big class and run it in the playground and it works fine:

let string = "1.213"
if let value = NSNumberFormatter().numberFromString(string)?.doubleValue 
{
  println("value = \(value)")
}

Displays the result

value = 1.213

Where is your variable "string" defined in your class?

Answer 3

Notice that string is blue, like a keyword, not black, like other local variables.

I'd try local variable string ==> myString just to know for sure.

Answer 4

Just 'cuz I was seeing the same thing and noticed no one had commented past your last edit (and maybe a fellow Googler for this issue will see this someday):

For both of our situations the issue is infinite recursion - we're calling a method from itself infinitely. That's the bug. The implication in the crash of NSNumberFormatter is a red herring.