Experimental parser: use Terms instead of tuples

tools/lexer_generator/transition_keys.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 164 matching lines @@
     but a newly-created "mock" character range which is separate from all other
     character ranges.'''
     def get_bounds(name):
       bound = TransitionKey.__unique_key_counter
       TransitionKey.__unique_key_counter -= 1
       return [(bound, bound)]
     name = '__' + name
     return TransitionKey.__cached_key(None, name, get_bounds)
 
   @staticmethod
-  def __process_graph(encoding, graph, ranges, key_map):
-    key = graph[0]
+  def __process_term(encoding, term, ranges, key_map):
+    key = term.name()
+    args = term.args()
     if key == 'RANGE':
-      ranges.append((ord(graph[1]), ord(graph[2])))
+      ranges.append((ord(args[0]), ord(args[1])))
     elif key == 'LITERAL':
-      ranges.append((ord(graph[1]), ord(graph[1])))
+      ranges.append((ord(args[0]), ord(args[0])))
     elif key == 'CAT':
-      for x in [graph[1], graph[2]]:
-        TransitionKey.__process_graph(encoding, x, ranges, key_map)
+      for x in [args[0], args[1]]:
+        TransitionKey.__process_term(encoding, x, ranges, key_map)
     elif key == 'CHARACTER_CLASS':
-      class_name = graph[1]
+      class_name = args[0]
       if encoding.class_range(class_name):
         r = encoding.class_range(class_name)
         if class_name in key_map:
           assert key_map[class_name] == TransitionKey(encoding, [r])
         ranges.append(r)
       elif encoding.predefined_range_iter(class_name):
         rs = list(encoding.predefined_range_iter(class_name))
         if class_name in key_map:
           assert key_map[class_name] == TransitionKey(encoding, rs)
         ranges += rs
       elif class_name in key_map:
         ranges += key_map[class_name].__ranges
       else:
-        raise Exception('unknown character class [%s]' % graph[1])
+        raise Exception('unknown character class [%s]' % args[0])
     else:
       raise Exception('bad key [%s]' % key)
 
   @staticmethod
-  def character_class(encoding, graph, key_map):
-    '''Processes 'graph' (a representation of a character class in the rule
+  def character_class(encoding, term, key_map):
+    '''Processes 'term' (a representation of a character class in the rule
     file), and constructs a TransitionKey based on it. 'key_map' contains
     already constructed aliases for character classes (they can be used in the
     new character class). It is a map from strings (character class names) to
     TransitionKeys. For example, graph might represent the character class
     [a-z:digit:] where 'digit' is a previously constructed character class found
     in "key_map".'''
     ranges = []
-    assert graph[0] == 'CLASS' or graph[0] == 'NOT_CLASS'
-    invert = graph[0] == 'NOT_CLASS'
-    TransitionKey.__process_graph(encoding, graph[1], ranges, key_map)
+    assert term.name() == 'CLASS' or term.name() == 'NOT_CLASS'
+    invert = term.name() == 'NOT_CLASS'
+    assert len(term.args()) == 1
+    TransitionKey.__process_term(encoding, term.args()[0], ranges, key_map)
     return TransitionKey.__key_from_ranges(encoding, invert, ranges)
 
   def matches_char(self, char):
     char = ord(char)
     assert char < 128
     for r in self.__ranges:
       if r[0] <= char and char <= r[1]: return True
     return False
 
   def is_superset_of_key(self, key):
@@ skipping 296 matching lines @@
         self.class_range('non_primary_whitespace')])
     self.add_predefined_range(
       'letter', [(65, 90), (97, 122), self.class_range('non_primary_letter')])
     self.add_predefined_range(
       'line_terminator',
       [(10, 10), (13, 13), self.class_range('non_primary_line_terminator')])
     self.add_predefined_range(
       'identifier_part_not_letter',
       [(48, 57), (95, 95),
        self.class_range('non_primary_identifier_part_not_letter')])