Experimental parser: always add all subtrees

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 138 matching lines @@
     (start, ends) = self.__process(subtree)
     state = self.__peek_state()
     if not state['start_node']:
       state['start_node'] = self.__new_state()
     self.__patch_ends(ends, state['start_node'])
     return (start, [])
 
   def __unique_key(self, name):
     return self.__key_state(TransitionKey.unique(name))
 
-  def __join(self, graph, name, subgraph):
-    subgraphs = self.__peek_state()['subgraphs']
-    if not name in subgraphs:
-      subgraphs[name] = self.__nfa(subgraph)
-    (subgraph_start, subgraph_end, nodes_in_subgraph) = subgraphs[name]
-    (start, ends) = self.__process(graph)
-    self.__patch_ends(ends, subgraph_start)
-    if subgraph_end:
-      end = self.__new_state()
-      subgraph_end.add_epsilon_transition(end)
-      return (start, [end])
+  def __join(self, tree, subtree):
+    (subtree_start, subtree_end, nodes_in_subtree) = self.__nfa(subtree)
+    (start, ends) = self.__process(tree)
+    self.__patch_ends(ends, subtree_start)
+    if subtree_end:
+      return (start, [subtree_end])
     else:
       return (start, [])
 
   def __process(self, term):
     assert isinstance(term, Term)
     method = "_NfaBuilder__" + term.name().lower()
     if not method in self.__operation_map:
       matches = filter(lambda (name, func): name == method, self.__members)
       assert len(matches) == 1
       self.__operation_map[method] = matches[0][1]
     return self.__operation_map[method](*term.args())
 
   def __patch_ends(self, ends, new_end):
     for end in ends:
       end.close(new_end)
 
   def __push_state(self):
     self.__states.append({
       'start_node' : None,
-      'subgraphs' : {},
-      'unpatched_ends' : [],
     })
 
   def __pop_state(self):
     return self.__states.pop()
 
   def __peek_state(self):
     return self.__states[-1]
 
   def __nfa(self, term):
     start_node_number = self.__node_number
     self.__push_state()
     (start, ends) = self.__process(term)
     state = self.__pop_state()
     if state['start_node']:
       state['start_node'].close(start)
       start = state['start_node']
-    for k, subgraph in state['subgraphs'].items():
-      if subgraph[1]:
-        subgraph[1].close(None)
-
     # Don't create an end node for the subgraph if it would be unused (ends can
     # be an empty list e.g., in the case when everything inside the subgraph is
     # "continue").
     end = None
     if ends:
       end = self.__new_state()
       self.__patch_ends(ends, end)
-
     return (start, end, self.__node_number - start_node_number)
 
   @staticmethod
   def __compute_epsilon_closures(start_state):
     def outer(node, state):
       def inner(node, closure):
         closure.add(node)
         return closure
       is_epsilon = lambda k: k == TransitionKey.epsilon()
       state_iter = lambda node : node.state_iter(key_filter = is_epsilon)
@@ skipping 46 matching lines @@
 
   @staticmethod
   def add_continue(term):
     return Term('CONTINUE', term)
 
   @staticmethod
   def unique_key(name):
     return Term('UNIQUE_KEY', name)
 
   @staticmethod
-  def join_subgraph(term, name, subgraph_term):
-    return Term('JOIN', term, name, subgraph_term)
+  def join_subgraph(tree, subtree):
+    return Term('JOIN', tree, subtree)
 
   @staticmethod
   def or_terms(terms):
     return reduce(lambda acc, g: Term('OR', acc, g), terms)
 
   @staticmethod
   def cat_terms(terms):
     return reduce(lambda acc, g: Term('CAT', acc, g), terms)
 
   __modifer_map = {
     '+': 'ONE_OR_MORE',
     '?': 'ZERO_OR_ONE',
     '*': 'ZERO_OR_MORE',
   }
 
   @staticmethod
   def apply_modifier(modifier, term):
     return Term(NfaBuilder.__modifer_map[modifier], term)