Build NFA for each token pattern

lib/imbecile.rb

@@ -1,6 +1,7 @@
 require_relative "imbecile/cli"
 require_relative "imbecile/grammar"
 require_relative "imbecile/regex"
+require_relative "imbecile/regex/nfa"
 require_relative "imbecile/regex/parser"
 require_relative "imbecile/version"
 require "erb"

lib/imbecile/grammar.rb

@@ -21,10 +21,10 @@ module Imbecile
           @modulename = $1
         elsif line =~ /^\s*class\s+(\S+)$/
           @classname = $1
-        elsif line =~ /^\s*token\s+(\S+)(?:\s+(.*))?$/
+        elsif line =~ /^\s*token\s+(\S+)(?:\s+(\S+))?$/
-          name, expr = $1, $2
+          name, pattern = $1, $2
-          if expr == ""
+          if pattern.to_s == ""
-            expr = name
+            pattern = name
           end
           unless name =~ /^[a-zA-Z_][a-zA-Z_0-9]*$/
             raise Error.new("Invalid token name #{name} on line #{line_number}")
@@ -32,15 +32,16 @@ module Imbecile
           if @tokens[name]
             raise Error.new("Duplicate token name #{name} on line #{line_number}")
           end
-          @tokens[name] = expr
+          @tokens[name] = {pattern: pattern}
         else
           raise Error.new("Unexpected input on line #{line_number}: #{line}")
         end
       end
 
       # Build NFA from each token expression.
-      @tokens.transform_values! do |expr|
+      @tokens.each do |token_name, token_def|
-        LexerNFA.new(expr)
+        token_def[:regex] = Regex.new(token_def[:pattern])
+        token_def[:nfa] = token_def[:regex].parser.unit.to_nfa
       end
     end
 

lib/imbecile/regex.rb

@@ -1,20 +1,10 @@
 module Imbecile
   class Regex
 
-    class State
+    attr_accessor :parser
-      attr_accessor :accepting
-
-      def initialize
-        @transitions = []
-      end
-
-      def add_transition(character_range, state)
-        @transitions << [character_range, state]
-      end
-    end
 
     def initialize(pattern)
-      parser = Parser.new(pattern)
+      @parser = Parser.new(pattern)
     end
 
   end