Experimental parser: cleanup after grammar refactor

tools/lexer_generator/dfa.py

 # Copyright 2013 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
 #       disclaimer in the documentation and/or other materials provided
@@ skipping 99 matching lines @@
   def terminal_set(self):
     return set(self.__terminal_set)
 
   @staticmethod
   def __match_char(state, char):
     match = list(state.state_iter(key_filter = lambda k: k.matches_char(char)))
     if not match: return None
     assert len(match) == 1
     return match[0]
 
+  @staticmethod
+  def terminal_action():
+    return Action(None, ('TERMINATE', None))
+
+  @staticmethod
+  def miss_action():
+    return Action(None, ('Miss', None))
+
   def collect_actions(self, string):
     state = self.__start
     for c in string:
       state = Dfa.__match_char(state, c)
       if not state:
-        yield Action('MISS')
+        yield self.miss_action()
         return
       if state.action():
         yield state.action()
     if state in self.__terminal_set:
-      yield Action('TERMINATE')
+      yield self.terminal_action()
     else:
-      yield Action('MISS')
+      yield self.miss_action()
 
   def matches(self, string):
     actions = list(self.collect_actions(string))
-    return actions and actions[-1].entry_action() == 'TERMINATE'
+    return actions and actions[-1] == self.terminal_action()
 
   def lex(self, string):
     state = self.__start
     last_position = 0
     for pos, c in enumerate(string):
       next = Dfa.__match_char(state, c)
       if not next:
         assert state.action() # must invoke default action here
         yield (state.action(), last_position, pos)
         last_position = pos
@@ skipping 200 matching lines @@
           elif len(intersection) <= len(difference):
             working_set.add(intersection)
           else:
             working_set.add(difference)
         if old_partitions:
           partitions -= old_partitions
         if new_partitions:
           partitions |= new_partitions
     (start_name, mapping) = self.__merge_partitions(partitions)
     return Dfa(start_name, mapping)