Experimental parser: remove some dead code

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 128 matching lines @@
     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 __catch_all(self, graph):
     return self.__key_state(TransitionKey.unique('catch_all'))
 
   def __join(self, graph):
-    (graph, name, subgraph, modifier) = graph[1:]
+    (graph, name, subgraph) = graph[1:]
     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)
-    if modifier:
-      assert modifier == 'ZERO_OR_MORE'
-      for end in ends:
-        end.add_epsilon_transition(subgraph_end)
     self.__patch_ends(ends, subgraph_start)
     end = self.__new_state()
     subgraph_end.add_epsilon_transition(end)
     return (start, [end])
 
   def __process(self, graph):
     assert type(graph) == TupleType
     method = "_NfaBuilder__" + graph[0].lower()
     if not method in self.__operation_map:
       matches = filter(lambda (name, func): name == method, self.__members)
@@ skipping 38 matching lines @@
 
   @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)
       edge = set(state_iter(node))
-      closure = Automaton.visit_states(edge, inner, state_iter=state_iter, visit_state=set())
+      closure = Automaton.visit_states(
+          edge, inner, state_iter=state_iter, visit_state=set())
       node.set_epsilon_closure(closure)
     Automaton.visit_states(set([start_state]), outer)
 
   @staticmethod
   def __replace_catch_all(state):
     catch_all = TransitionKey.unique('catch_all')
     transitions = state.transitions()
     if not catch_all in transitions:
       return
     f = lambda acc, state: acc | set(state.epsilon_closure_iter())
@@ skipping 25 matching lines @@
 
   @staticmethod
   def catch_all():
     return ('CATCH_ALL',)
 
   @staticmethod
   def epsilon():
     return ('EPSILON',)
 
   @staticmethod
-  def join_subgraph(graph, name, subgraph, modifier):
-    if modifier:
-      modifier = NfaBuilder.__modifer_map[modifier]
-    return ('JOIN', graph, name, subgraph, modifier)
+  def join_subgraph(graph, name, subgraph):
+    return ('JOIN', graph, name, subgraph)
 
   @staticmethod
   def or_graphs(graphs):
     return reduce(lambda acc, g: ('OR', acc, g), graphs)
 
   @staticmethod
   def cat_graphs(graphs):
     return reduce(lambda acc, g: ('CAT', acc, g), graphs)
 
   __modifer_map = {
     '+': 'ONE_OR_MORE',
     '?': 'ZERO_OR_ONE',
     '*': 'ZERO_OR_MORE',
   }
 
   @staticmethod
   def apply_modifier(modifier, graph):
     return (NfaBuilder.__modifer_map[modifier], graph)