Experimental parser: cleanup transition_keys a bit

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 30 matching lines @@
       Utf16Encoding()
       Utf8Encoding()
     return KeyEncoding.__encodings[name]
 
   def __init__(self, name, primary_range, named_ranges, predefined_ranges):
     assert not name in KeyEncoding.__encodings
     assert primary_range[0] <= primary_range[1]
     KeyEncoding.__encodings[name] = self
     self.__name = name
     self.__primary_range = primary_range
-    self.__primary_range_component = Term(
-      'NUMERIC_RANGE_KEY', primary_range[0], primary_range[1])
     self.__lower_bound = primary_range[0]
     self.__upper_bound = primary_range[1]
+    self.__primary_range_component = self.numeric_range_term(primary_range[0],
+                                                             primary_range[1])
     self.__named_ranges = {
       k : Term('NAMED_RANGE_KEY', k) for k in named_ranges }
     def f(v):
       if len(v) == 2:
-        assert primary_range[0] <= v[0] and v[1] <= primary_range[1]
-        return Term('NUMERIC_RANGE_KEY', v[0], v[1])
+        return self.numeric_range_term(v[0], v[1])
       elif len(v) == 1:
         assert v[0] in self.__named_ranges
         return self.__named_ranges[v[0]]
       else:
         raise Exception()
     self.__predefined_ranges = {
       k : map(f, v) for k, v in predefined_ranges.iteritems() }
 
   def name(self):
     return self.__name
@@ skipping 24 matching lines @@
     ranges = self.__predefined_ranges
     return None if not name in ranges else iter(ranges[name])
 
   def __primary_range_iter(self):
     yield self.__primary_range_component
 
   def all_components_iter(self):
     return chain(self.__primary_range_iter(), self.__named_ranges.itervalues())
 
   def is_primary_range(self, r):
-    assert self.lower_bound() <= r[0] and r[1] <= self.upper_bound()
-    primary_range = self.__primary_range
-    if (primary_range[0] <= r[0] and r[1] <= primary_range[1]):
-      return True
-    assert r[0] == r[1]
-    return False
+    assert len(r) == 2
+    return self.in_primary_range(r[0], r[1])
 
-  def in_primary_range(self, c):
-    return self.is_primary_range((c, c))
+  def in_primary_range(self, a, b):
+    return self.lower_bound() <= a and b <= self.upper_bound()
+
+  def numeric_range_term(self, a, b):
+    assert type(a) == IntType and type(b) == IntType
+    assert self.in_primary_range(a, b)
+    return Term('NUMERIC_RANGE_KEY', a, b)
 
 class TransitionKey(object):
   '''Represents a transition from a state in DFA or NFA to another state.
 
   A transition key has a list of character ranges and a list of class ranges
   (e.g., "whitespace"), defining for which characters the transition
   happens. When we generate code based on the transition key, the character
   ranges generate simple checks and the class ranges generate more complicated
   conditions, e.g., function calls.'''
 
@@ skipping 30 matching lines @@
         lambda : encoding.all_components_iter())
 
   @staticmethod
   def single_char(encoding, char):
     '''Returns a TransitionKey for a single-character transition.'''
     return TransitionKey.range(encoding, char, char)
 
   @staticmethod
   def range(encoding, a, b):
     '''Returns a TransitionKey for a single-character transition.'''
-    assert type(a) == IntType and type(b) == IntType
-    return TransitionKey(encoding, Term("NUMERIC_RANGE_KEY", a, b))
+    return TransitionKey(encoding, encoding.numeric_range_term(a, b))
 
   @staticmethod
   def unique(term):  # TODO(dcarney): rename
     '''Returns a unique TransitionKey for the given name (and creates it if it
     doesn't exist yet). The TransitionKey won't have any real character range,
     but a newly-created "mock" character range which is separate from all other
     character ranges.'''
     return TransitionKey(None, Term("TERM_KEY", term))
 
   @staticmethod
   def __process_term(encoding, term, components, key_map):
     key = term.name()
     args = term.args()
     if key == 'RANGE':
-      components.append(Term('NUMERIC_RANGE_KEY', args[0], args[1]))
+      components.append(encoding.numeric_range_term(args[0], args[1]))
     elif key == 'LITERAL':
-      components += map(lambda x : Term('NUMERIC_RANGE_KEY', x, x), args)
+      components += map(lambda x : encoding.numeric_range_term(x, x), args)
     elif key == 'CAT':
       for x in args:
         TransitionKey.__process_term(encoding, x, components, key_map)
     elif key == 'CHARACTER_CLASS':
       class_name = args[0]
       if encoding.named_range(class_name):
         c = encoding.named_range(class_name)
         if class_name in key_map:
           assert key_map[class_name] == TransitionKey(encoding, c)
         components.append(c)
@@ skipping 145 matching lines @@
     elif component.name() == 'NAMED_RANGE_KEY':
       return component.args()[0]
     elif component.name() == 'EPSILON_KEY':
       return 'epsilon'
     elif component.name() == 'OMEGA_KEY':
       return 'omega'
     elif component.name() != 'NUMERIC_RANGE_KEY':
       raise Exception('unprintable %s' % component)
     r = component.args()
     def to_str(x):
-      assert not encoding or encoding.in_primary_range(x)
+      assert not encoding or encoding.in_primary_range(x, x)
       if x > 127:
         return str(x)
       if not x in TransitionKey.__printable_cache:
         res = "'%s'" % chr(x) if chr(x) in printable else str(x)
         TransitionKey.__printable_cache[x] = res
       return TransitionKey.__printable_cache[x]
     if r[0] == r[1]:
       return '%s' % to_str(r[0])
     else:
       return '[%s-%s]' % (to_str(r[0]), to_str(r[1]))
@@ skipping 153 matching lines @@
         other_keys.add(x)
         continue
       (start, end) = x.args()
       if not start in range_map:
         range_map[start] = []
       range_map[start].append(end)
     ranges = TransitionKey.__disjoint_keys(encoding, range_map)
     if merge_ranges:
       ranges = TransitionKey.__merge_ranges(encoding, ranges)
       other_keys = sorted(other_keys, cmp=TransitionKey.__component_compare)
-    range_terms = map(lambda x : Term('NUMERIC_RANGE_KEY', x[0], x[1]), ranges)
+    range_terms = map(
+      lambda x : encoding.numeric_range_term(x[0], x[1]), ranges)
     return chain(iter(range_terms), iter(other_keys))
 
   @staticmethod
   def __key_from_components(encoding, invert, components):
     components = TransitionKey.__disjoint_components(encoding, components, True)
     if invert:
       components = TransitionKey.__invert_components(encoding, components)
     return None if not components else TransitionKey(encoding, components)
 
   @staticmethod
@@ skipping 20 matching lines @@
       encoding, True, TransitionKey.__flatten_keys(keys))
 
   @staticmethod
   def merged_key(encoding, keys):
     return TransitionKey(encoding,
       TransitionKey.__disjoint_components_from_keys(encoding, keys, True))
 
   @staticmethod
   def __invert_components(encoding, components):
     def key(x, y):
-      return Term('NUMERIC_RANGE_KEY', x, y)
+      return encoding.numeric_range_term(x, y)
     last = None
     classes = set(encoding.named_range_value_iter())
     for c in components:
       if c in classes:
         classes.remove(c)
         continue
       assert c.name() == 'NUMERIC_RANGE_KEY', 'unencoded key not invertible'
       r = c.args()
       assert encoding.is_primary_range(r)
       if last == None:
@@ skipping 69 matching lines @@
       {
         'whitespace':
           [(9, 9), (11, 12), (32, 32), ('non_primary_whitespace',)],
         'letter':
           [(65, 90), (97, 122), ('non_primary_letter',)],
         'line_terminator':
           [(10, 10), (13, 13), ('non_primary_line_terminator',)],
         'identifier_part_not_letter':
           [(48, 57), (95, 95), ('non_primary_identifier_part_not_letter',)],
       })