Experimental parser: cleanup dfa.py

tools/lexer_generator/nfa.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 112 matching lines @@
       return count + 1
     count = self.visit_all_states(f, 0)
     assert count == nodes_created
 
   @staticmethod
   def __gather_transition_keys(encoding, state_set):
     keys = set(chain(*map(lambda state: state.key_iter(), state_set)))
     keys.discard(TransitionKey.epsilon())
     return TransitionKey.disjoint_keys(encoding, keys)
 
-  def __to_dfa(self, nfa_state_set, dfa_nodes, end_node):
+  def __to_dfa(self, nfa_state_set, dfa_nodes):
     nfa_state_set = Automaton.epsilon_closure(nfa_state_set)
     # nfa_state_set will be a state in the dfa.
     assert nfa_state_set
     name = ".".join(str(x.node_number()) for x in sorted(nfa_state_set))
     if name in dfa_nodes:
       return name
     dfa_nodes[name] = {
       'transitions': {},
-      'terminal': end_node in nfa_state_set,
+      'terminal': self.__end in nfa_state_set,
       'action' : Action.dominant_action(nfa_state_set)}
     # Gather the set of transition keys for which the dfa state will have
     # transitions (the disjoint set of all the transition keys from all the
     # states combined). For example, if a state in the state set has a
     # transition for key [a-c], and another state for [b-d], the dfa state will
     # have transitions with keys ([a], [b-c], [d]).
     for key in Nfa.__gather_transition_keys(self.encoding(), nfa_state_set):
       # Find out which states we can reach with "key", starting from any of the
       # states in "nfa_state_set". The corresponding dfa state will have a
       # transition with "key" to a state which corresponds to the set of the
       # states ("match_states") (more accurately, its epsilon closure).
       f = lambda state: state.transition_state_iter_for_key(key)
       match_states = set(chain(*map(f, nfa_state_set)))
-      transition_state = self.__to_dfa(match_states, dfa_nodes, end_node)
+      transition_state = self.__to_dfa(match_states, dfa_nodes)
       dfa_nodes[name]['transitions'][key] = transition_state
     return name
 
   def compute_dfa(self):
     dfa_nodes = {}
-    start_name = self.__to_dfa(set([self.__start]), dfa_nodes, self.__end)
+    start_name = self.__to_dfa(set([self.__start]), dfa_nodes)
     return (start_name, dfa_nodes)