Experimental parser: action refactor

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 12 matching lines @@
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 from transition_keys import TransitionKey
 from automaton import *
 
 class NfaState(AutomatonState):
 
-  def __init__(self, node_number):
-    super(NfaState, self).__init__(node_number)
+  def __init__(self):
+    super(NfaState, self).__init__()
     self.__transitions = {}
     self.__unclosed = set()
     self.__epsilon_closure = None
     self.__action = None
 
   def transitions_to_multiple_states(self):
     return True
 
   def epsilon_closure(self):
     return self.__epsilon_closure
@@ skipping 98 matching lines @@
       valid_states = Nfa.__close(transitions)
     return self.__end in valid_states
 
   @staticmethod
   def __gather_transition_keys(state_set):
     keys = set(chain(*map(lambda state: state.key_iter(), state_set)))
     keys.discard(TransitionKey.epsilon())
     return TransitionKey.disjoint_keys(keys)
 
   @staticmethod
+  def __gather_actions(states):
+    action = None
+    for state in states:
+      if not state.action():
+        continue
+      if not action:
+        action = state.action()
+        continue
+      if state.action().precedence() == action.precedence():
+        assert state.action() == action
+      elif state.action().precedence() < action.precedence():
+        action = state.action()
+    return action
+
+  @staticmethod
   def __to_dfa(nfa_state_set, dfa_nodes, end_node):
     nfa_state_set = Nfa.__close(nfa_state_set)
     assert nfa_state_set
     name = ".".join(str(x.node_number()) for x in sorted(nfa_state_set))
     if name in dfa_nodes:
       return name
-    def gather_actions(states):
-      actions = set()
-      for state in states:
-        if state.action():
-          actions.add(state.action())
-      actions = list(actions)
-      actions.sort()
-      return actions
     dfa_nodes[name] = {
       'transitions': {},
       'terminal': end_node in nfa_state_set,
-      'actions' : gather_actions(nfa_state_set)}
+      'action' : Nfa.__gather_actions(nfa_state_set)}
     for key in Nfa.__gather_transition_keys(nfa_state_set):
       match_states = set()
       f = lambda acc, state: acc | state.key_matches(key)
       for state in reduce(f, nfa_state_set, set()):
         match_states.add(state)
       transition_state = Nfa.__to_dfa(match_states, dfa_nodes, end_node)
       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)
     return (start_name, dfa_nodes)