Experimental parser: better actions

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 67 matching lines @@
              | empty'''
 
   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': None,
+        'default_action': 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_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'
+    '''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:
       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]
-    if p[1] == 'default':
-      assert not rules['default']
-      rules['default'] = rule
+    code = p[2]
+    if p[1] == 'default_action':
+      assert not rules['default_action']
+      rules['default_action'] = code
     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_or_default(self, p):
-    '''composite_regex_or_default : DEFAULT
-                                  | composite_regex'''
-    p[0] = p[1]
-
   def p_composite_regex(self, p):
     '''composite_regex : regex_parts OR regex_parts
                        | regex_parts'''
     if len(p) == 2:
       p[0] = p[1]
     else:
       p[0] = NfaBuilder.or_graphs([p[1], p[3]])
 
   def p_regex_parts(self, p):
     '''regex_parts : regex_part
@@ skipping 70 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())