Experimental parser: always apply default transitions

tools/lexer_generator/nfa_builder.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 135 matching lines @@
   def __unique_key(self, name):
     return self.__key_state(TransitionKey.unique(name))
 
   def __entry_action(self, action, precedence, subtree):
     (start, ends) = self.__process(subtree)
     node = self.__new_state()
     node.set_action(Action(action, precedence))
     self.__patch_ends(ends, node)
     return (start, [node])
 
-  def __match_action(self, action, precedence, subtree):
-    (start, ends) = self.__process(subtree)
+  def __build_match_node(self, action):
     node = self.__new_state()
-    node.set_action(Action(action, precedence))
+    node.set_action(action)
     # Force all match actions to be terminal.
     node.close(self.__global_end)
     # patch via a match edge into existing graph
     match_node = self.__new_state()
     match_node.add_transition(TransitionKey.omega(), node)
+    return match_node
+
+  def __match_action(self, action, precedence, subtree):
+    (start, ends) = self.__process(subtree)
+    match_node =  self.__build_match_node(Action(action, precedence))
     self.__patch_ends(ends, match_node)
     return (start, [match_node])
 
   def __continue(self, subtree, depth):
     'add an epsilon transitions to the start node of the current subtree'
     (start, ends) = self.__process(subtree)
     index = -1 - min(int(depth), len(self.__states) - 1)
     state = self.__states[index]
     if not state['start_node']:
       state['start_node'] = self.__new_state()
@@ skipping 109 matching lines @@
     return terms[0] if len(terms) == 1 else Term('OR', *terms)
 
   @staticmethod
   def cat_terms(terms):
     terms = NfaBuilder.__flatten_terms(terms, 'CAT')
     terms = list(NfaBuilder.__flatten_literals(terms))
     assert terms
     return terms[0] if len(terms) == 1 else Term('CAT', *terms)
 
   @staticmethod
-  def nfa(encoding, character_classes, subtree_map, name):
+  def nfa(encoding, character_classes, subtree_map,
+          name, default_action = Action.empty_action()):
     self = NfaBuilder(encoding, character_classes, subtree_map)
     (start, ends) = self.__subgraph(name)
     # close all ends
+    for e in ends:
+      match_node =  self.__build_match_node(default_action)
+      e.close(match_node)
+      match_node.close(None)
     end = self.__global_end
     end.close(None)
-    # TODO(dcarney): patch in default action
-    self.__patch_ends(ends, end)
     # Prepare the nfa
     self.__compute_epsilon_closures(start)
     f = lambda node, state: self.__replace_catch_all(self.__encoding, node)
     Automaton.visit_states(set([start]), f)
     return Nfa(self.__encoding, start, end, self.__node_number)
 
   @staticmethod
   def __compute_epsilon_closures(start_state):
     def outer(node, state):
       def inner(node, closure):
@@ skipping 23 matching lines @@
     inverse_key = TransitionKey.inverse_key(encoding, keys)
     if not inverse_key:
       inverse_key = TransitionKey.unique('no_match')
     state.swap_key(catch_all, inverse_key)
 
   @staticmethod
   def __install_omega_transitions(start_state, default_action):
     '''install a match transition, a backtrack transition,
     or a default transition into all nodes'''
     pass