Experimental parser: use names instead of offsets in nfabuilder dispatch

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 41 matching lines @@
 
   def __new_state(self):
     self.__node_number += 1
     return NfaState()
 
   def __global_end(self):
     if not self.__global_end_node:
       self.__global_end_node = self.__new_state()
     return self.__global_end_node
 
-  def __or(self, args):
+  def __or(self, left, right):
     start = self.__new_state()
     ends = []
-    for x in [self.__process(args[0]), self.__process(args[1])]:
-      start.add_epsilon_transition(x[0])
-      ends += x[1]
+    for (sub_start, sub_end) in [self.__process(left), self.__process(right)]:
+      start.add_epsilon_transition(sub_start)
+      ends += sub_end
     start.close(None)
     return (start, ends)
 
-  def __one_or_more(self, args):
-    (start, ends) = self.__process(args[0])
+  def __one_or_more(self, subtree):
+    (start, ends) = self.__process(subtree)
     end =  self.__new_state()
     end.add_epsilon_transition(start)
     self.__patch_ends(ends, end)
     return (start, [end])
 
-  def __zero_or_more(self, args):
-    (node, ends) = self.__process(args[0])
+  def __zero_or_more(self, subtree):
+    (node, ends) = self.__process(subtree)
     start =  self.__new_state()
     start.add_epsilon_transition(node)
     self.__patch_ends(ends, start)
     return (start, [start])
 
-  def __zero_or_one(self, args):
-    (node, ends) = self.__process(args[0])
+  def __zero_or_one(self, subtree):
+    (node, ends) = self.__process(subtree)
     start =  self.__new_state()
     start.add_epsilon_transition(node)
     return (start, ends + [start])
 
-  def __repeat(self, args):
-    param_min = int(args[0])
-    param_max = int(args[1])
-    subgraph = args[2]
-    (start, ends) = self.__process(subgraph)
+  def __repeat(self, param_min, param_max, subtree):
+    param_min = int(param_min)
+    param_max = int(param_max)
+    (start, ends) = self.__process(subtree)
     for i in xrange(1, param_min):
-      (start2, ends2) = self.__process(subgraph)
+      (start2, ends2) = self.__process(subtree)
       self.__patch_ends(ends, start2)
       ends = ends2
     if param_min == param_max:
       return (start, ends)
 
     midpoints = []
     for i in xrange(param_min, param_max):
       midpoint =  self.__new_state()
       self.__patch_ends(ends, midpoint)
-      (start2, ends) = self.__process(subgraph)
+      (start2, ends) = self.__process(subtree)
       midpoint.add_epsilon_transition(start2)
       midpoints.append(midpoint)
 
     return (start, ends + midpoints)
 
-  def __cat(self, args):
-    (left, right) = (self.__process(args[0]), self.__process(args[1]))
+  def __cat(self, left_tree, right_tree):
+    (left, right) = (self.__process(left_tree), self.__process(right_tree))
     self.__patch_ends(left[1], right[0])
     return (left[0], right[1])
 
   def __key_state(self, key):
     state =  self.__new_state()
     state.add_unclosed_transition(key)
     return (state, [state])
 
-  def __literal(self, args):
-    assert len(args) == 1
+  def __literal(self, char):
     return self.__key_state(
-      TransitionKey.single_char(self.__encoding, args[0]))
+      TransitionKey.single_char(self.__encoding, char))
 
-  def __class(self, args):
-    assert len(args) == 1
+  def __class(self, subtree):
     return self.__key_state(TransitionKey.character_class(
-      self.__encoding, Term('CLASS', args[0]), self.__character_classes))
+      self.__encoding, Term('CLASS', subtree), self.__character_classes))
 
-  def __not_class(self, args):
-    assert len(args) == 1
+  def __not_class(self, subtree):
     return self.__key_state(TransitionKey.character_class(
-      self.__encoding, Term('NOT_CLASS', args[0]), self.__character_classes))
+      self.__encoding, Term('NOT_CLASS', subtree), self.__character_classes))
 
-  def __any(self, args):
+  def __any(self):
     return self.__key_state(TransitionKey.any(self.__encoding))
 
-  def __action(self, args):
-    (start, ends) = self.__process(args[0])
-    action = Action.from_term(args[1])
+  def __action(self, subtree, action_term):
+    (start, ends) = self.__process(subtree)
+    action = Action.from_term(action_term)
     end = self.__new_state()
     self.__patch_ends(ends, end)
     end.set_action(action)
     if action.match_action():
       global_end = self.__global_end()
       end.add_epsilon_transition(global_end)
     return (start, [end])
 
-  def __continue(self, args):
-    (start, ends) = self.__process(args[0])
+  def __continue(self, subtree):
+    (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, args):
-    return self.__key_state(TransitionKey.unique(args[0]))
+  def __unique_key(self, name):
+    return self.__key_state(TransitionKey.unique(name))
 
-  def __join(self, (graph, name, subgraph)):
+  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])
     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())
+    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' : [],
@@ skipping 104 matching lines @@
 
   __modifer_map = {
     '+': 'ONE_OR_MORE',
     '?': 'ZERO_OR_ONE',
     '*': 'ZERO_OR_MORE',
   }
 
   @staticmethod
   def apply_modifier(modifier, term):
     return Term(NfaBuilder.__modifer_map[modifier], term)