Experimental parser: add catch all rule

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 68 matching lines @@
 
   def p_state_change(self, p):
     '''state_change : LESS_THAN IDENTIFIER GREATER_THAN
                     | LESS_THAN DEFAULT GREATER_THAN'''
     state = self.__state
     state.current_state = p[2]
     assert state.current_state
     if not state.current_state in state.rules:
       state.rules[state.current_state] = {
         'default_action': None,
+        'catch_all' : None,
         'regex' : []
       }
     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 code action
                        | composite_regex empty action
                        | composite_regex code empty
-                       | DEFAULT_ACTION code empty'''
-    transition = p[3] if p[3] else 'break'
-    if not transition in self.__keyword_transitions:
+                       | DEFAULT_ACTION code empty
+                       | CATCH_ALL empty action'''
+    transition = p[3]
+    if transition and not transition in self.__keyword_transitions:
       assert not transition == 'default'
       self.__state.transitions.add(transition)
     RuleParser.__rule_precedence_counter += 1
     rules = self.__state.rules[self.__state.current_state]
     code = p[2]
     if p[1] == 'default_action':
       assert not rules['default_action']
       rules['default_action'] = code
+    elif p[1] == 'catch_all':
+      assert not rules['catch_all']
+      rules['catch_all'] = transition
     else:
       rule = (p[1], (RuleParser.__rule_precedence_counter, code, transition))
       rules['regex'].append(rule)
 
   def p_action(self, p):
     'action : ACTION_OPEN IDENTIFIER ACTION_CLOSE'
     p[0] = p[2]
 
   def p_composite_regex(self, p):
     '''composite_regex : regex_parts OR regex_parts
@@ skipping 78 matching lines @@
       parser.build()
       RuleParser.__static_instance = parser
     parser.__state = parser_state
     try:
       parser.parser.parse(data, lexer=parser.lexer.lexer)
     except Exception:
       RuleParser.__static_instance = None
       raise
     parser.__state = None
     assert parser_state.transitions <= set(parser_state.rules.keys())