From ed274947839e3f2936dd9b5f295b7c07422d04b9 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Mon, 19 Dec 2016 09:46:58 -0800
Subject: [PATCH] Try to lex identifiers and parens

---
 Sibil/Characters.swift | 10 +++++-----
 Sibil/Lexer.swift      | 18 +++++++++++++++---
 Sibil/main.swift       |  2 +-
 3 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/Sibil/Characters.swift b/Sibil/Characters.swift
index 58f82fb..6942d87 100644
--- a/Sibil/Characters.swift
+++ b/Sibil/Characters.swift
@@ -33,10 +33,10 @@ extension CharacterSet {
         return subsequents
     }()
 
-    func contains(_ char: Character) -> Bool {
-        let cSet = CharacterSet(charactersIn: String(char))
-        let isSuperset = self.isSuperset(of: cSet)
-        return isSuperset
+    func contains(_ c: Character) -> Bool {
+        let cSet = CharacterSet(charactersIn: String(c))
+        let containsC = isSuperset(of: cSet)
+        return containsC
     }
 }
 
@@ -51,7 +51,7 @@ extension Character {
     }
 
     var isIdentifierInitial: Bool {
-        return false
+        return CharacterSet.identifierInitials.contains(self)
     }
 
     var isIdentifierSubsequent: Bool {
diff --git a/Sibil/Lexer.swift b/Sibil/Lexer.swift
index 8f91546..e6005ce 100644
--- a/Sibil/Lexer.swift
+++ b/Sibil/Lexer.swift
@@ -13,6 +13,7 @@ struct Token: CustomDebugStringConvertible {
     enum Kind {
         case LeftParen
         case RightParen
+        case Identifier
     }
     
     let kind: Kind
@@ -79,20 +80,28 @@ extension Lexer: Sequence, IteratorProtocol {
         }
 
         while state != .Emit {
-            let c = input[index]
+            let c = input[forward]
+            print("processing '\(c)' in \(state)")
             switch state {
             case .Initial:
                 if c.isLeftParen {
-
+                    emit(.LeftParen)
                 }
                 else if c.isRightParen {
-
+                    emit(.RightParen)
                 }
                 else if c.isIdentifierInitial {
                     advance()
                     toState(.Identifier)
                 }
             case .Identifier:
+                if c.isIdentifierSubsequent {
+                    advance()
+                }
+                else {
+                    retract()
+                    emit(.Identifier)
+                }
                 break
             case .Emit:
                 // Nothing to do for this state
@@ -100,6 +109,9 @@ extension Lexer: Sequence, IteratorProtocol {
             }
         }
 
+        // Set up for the next token.
+        index = input.index(after: forward)
+
         return token
     }
 }
diff --git a/Sibil/main.swift b/Sibil/main.swift
index b72e9f7..300d31f 100644
--- a/Sibil/main.swift
+++ b/Sibil/main.swift
@@ -8,7 +8,7 @@
 
 import Foundation
 
-let l = Lexer(input: "(())")
+let l = Lexer(input: "((abc))")
 for t in l {
     print(t)
 }