Experimental parser: some cleanup and assertions for rule_parser

tools/lexer_generator/rule_parser.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 22 matching lines @@
 
 class RuleParserState:
 
   def __init__(self):
     self.aliases = {
       'eof' : RegexParser.parse("[\\0]"),
     }
     self.character_classes = {}
     self.current_state = None
     self.rules = {}
+    self.transitions = set()
 
   def parse(self, string):
     return RuleParser.parse(string, self)
 
 class RuleParser:
 
   tokens = RuleLexer.tokens
   __rule_precedence_counter = 0
+  __keyword_transitions = set([
+      'continue', 'break', 'terminate', 'terminate_illegal'])
 
   def __init__(self):
     self.__state = None
 
   def p_statements(self, p):
     'statements : aliases rules'
 
   def p_aliases(self, p):
     '''aliases : alias_rule aliases
                | empty'''
@@ skipping 27 matching lines @@
     p[0] = state.current_state
 
   def p_transition_rules(self, p):
     '''transition_rules : transition_rule transition_rules
                         | empty'''
 
   def p_transition_rule(self, p):
     '''transition_rule : composite_regex_or_default code action
                        | composite_regex_or_default empty action
                        | composite_regex_or_default code empty'''
+    transition = p[3] if p[3] else 'continue'
+    if transition == 'continue' and self.__state.current_state == 'default':
+      transition = 'break'
+    if not transition in self.__keyword_transitions:
+      assert not transition == 'default'
+      self.__state.transitions.add(transition)
+    rule = (p[1], (RuleParser.__rule_precedence_counter, p[2], transition))
+    RuleParser.__rule_precedence_counter += 1
     rules = self.__state.rules[self.__state.current_state]
-    rule = (p[1], RuleParser.__rule_precedence_counter, p[2], p[3])
-    RuleParser.__rule_precedence_counter += 1
     if p[1] == 'default':
       assert not rules['default']
       rules['default'] = rule
     else:
       rules['regex'].append(rule)
 
   def p_action(self, p):
     'action : ACTION_OPEN IDENTIFIER ACTION_CLOSE'
     p[0] = p[2]
 
@@ skipping 79 matching lines @@
   @staticmethod
   def parse(data, parser_state):
     parser = RuleParser.__static_instance
     if not parser:
       parser = RuleParser()
       parser.build()
       RuleParser.__static_instance = parser
     parser.__state = parser_state
     try:
       parser.parser.parse(data, lexer=parser.lexer.lexer)
-    except Exception as e:
+    except Exception:
       RuleParser.__static_instance = None
-      raise e
+      raise
+    assert parser_state.transitions <= set(parser_state.rules.keys())
     parser.__state = None