Experimental parser: better rule tree visualization

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, left, right):
+  def __or(self, *trees):
     start = self.__new_state()
     ends = []
-    for (sub_start, sub_end) in [self.__process(left), self.__process(right)]:
+    for tree in trees:
+      (sub_start, sub_end) = self.__process(tree)
       start.add_epsilon_transition(sub_start)
       ends += sub_end
     start.close(None)
     return (start, ends)
 
   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)
@@ skipping 27 matching lines @@
     # join in (param_max - param_min) optional subtrees
     midpoints = []
     for i in xrange(param_min, param_max):
       midpoint =  self.__new_state()
       self.__patch_ends(ends, midpoint)
       (start2, ends) = self.__process(subtree)
       midpoint.add_epsilon_transition(start2)
       midpoints.append(midpoint)
     return (start, ends + midpoints)
 
-  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 __cat(self, *trees):
+    (start, ends) = (None, None)
+    for tree in trees:
+      (sub_start, sub_ends) = self.__process(tree)
+      if start == None:
+        start = sub_start
+      else:
+        assert sub_ends, "this creates unreachable nodes"
+        self.__patch_ends(ends, sub_start)
+      ends = sub_ends
+    return (start, ends)
 
   def __key_state(self, key):
     state =  self.__new_state()
     state.add_unclosed_transition(key)
     return (state, [state])
 
-  def __literal(self, char):
+  def __literal(self, chars):
+    terms = map(lambda c : Term('SINGLE_CHAR', c), chars)
+    return self.__process(self.cat_terms(terms))
+
+  def __single_char(self, char):
     return self.__key_state(
       TransitionKey.single_char(self.__encoding, char))
 
   def __class(self, subtree):
     return self.__key_state(TransitionKey.character_class(
       self.__encoding, Term('CLASS', subtree), self.__character_classes))
 
   def __not_class(self, subtree):
     return self.__key_state(TransitionKey.character_class(
       self.__encoding, Term('NOT_CLASS', subtree), self.__character_classes))
@@ skipping 144 matching lines @@
   @staticmethod
   def unique_key(name):
     return Term('UNIQUE_KEY', name)
 
   @staticmethod
   def join_subtree(tree, subtree_name):
     return Term('JOIN', tree, subtree_name)
 
   @staticmethod
   def or_terms(terms):
-    return reduce(lambda acc, g: Term('OR', acc, g), terms)
+    if len(terms) == 1: return terms[0]
+    return Term('OR', *terms) if terms else Term.empty()
 
   @staticmethod
   def cat_terms(terms):
-    return reduce(lambda acc, g: Term('CAT', acc, g), terms)
+    if len(terms) == 1: return terms[0]
+    return Term('CAT', *terms) if terms else Term.empty()
 
   __modifer_map = {
     '+': 'ONE_OR_MORE',
     '?': 'ZERO_OR_ONE',
     '*': 'ZERO_OR_MORE',
   }
 
   @staticmethod
   def apply_modifier(modifier, term):
     return Term(NfaBuilder.__modifer_map[modifier], term)