         advance()
 
         var buffer = [CChar]()
-
-        LOOP: for ; cur != end; advance() {
+        
+        while cur != end && currentChar != Char(ascii: "\"") {
             switch currentChar {
             case Char(ascii: "\\"):
                 advance()
-                if (cur == end) {
+                
+                guard cur != end else {
                     throw InvalidStringError("unexpected end of a string literal", self)
                 }
-
-                if let c = parseEscapedChar() {
-                    for u in String(c).utf8 {
-                        buffer.append(CChar(bitPattern: u))
-                    }
-                } else {
+                
+                guard let escapedChar = parseEscapedChar() else {
                     throw InvalidStringError("invalid escape sequence", self)
                 }
-                break
-            case Char(ascii: "\""): // end of the string literal
-                break LOOP
+                
+                String(escapedChar).utf8.forEach {
+                    buffer.append(CChar(bitPattern: $0))
+                }
             default:
                 buffer.append(CChar(bitPattern: currentChar))
             }
-        }
-
-        if !expect("\"") {
+            
+            advance()
+        }
+
+        guard expect("\"") else {
             throw InvalidStringError("missing double quote", self)
         }
 
         buffer.append(0) // trailing nul
 
-        let s = String.fromCString(buffer)!
-        return .StringValue(s)
+        guard let string = String.fromCString(buffer) else {
+            throw InvalidStringError("Unable to parse CString", self)
+        }
+        
+        return .StringValue(string)
     }
 
     func parseEscapedChar() -> UnicodeScalar? {


        var p = target.utf8Start
        let endp = p.advancedBy(Int(target.byteSize))

        LOOP: for ; p != endp; p++, advance() {
            if p.memory != currentChar {
                cur = start // unread
                lineNumber = l
                columnNumber = c
                return false
            }
        }

        return true
    }


        case Char(ascii: "0"):
            advance()
        case Char(ascii: "1") ... Char(ascii: "9"):
            while let value = digitToInt(currentChar) where cur != end {
                integer = (integer * 10) + Int64(value)
                advance()
            }
        default:
            throw InvalidNumberError("invalid token in number", self)
        }

        if integer != Int64(Float80(integer)) {
            // TODO: Verify implications of Float80
            throw InvalidNumberError("too much integer part in number", self)
        }

        var fraction: Double = 0.0
