Experimental parser: easier to read rules and default 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 18 matching lines @@
 from rule_lexer import RuleLexer
 from regex_parser import RegexParser
 from nfa import NfaBuilder
 from transition_keys import TransitionKey
 
 class RuleParserState:
 
   def __init__(self):
     self.aliases = {
       'eof' : RegexParser.parse("[\\0]"),
-      'any' : RegexParser.parse("."),
     }
     self.character_classes = {}
-    self.current_transition = None
+    self.current_state = None
     self.rules = {}
 
   def parse(self, string):
     return RuleParser.parse(string, self)
 
 class RuleParser:
 
   tokens = RuleLexer.tokens
 
   def __init__(self):
     self.__state = None
 
   def p_statements(self, p):
-    'statements : statement maybe_statements'
+    'statements : aliases rules'
 
-  def p_maybe_statement(self, p):
-    '''maybe_statements : statements
-                        | empty'''
-
-  def p_statement(self, p):
-    '''statement : alias_rule
-                 | transition_rule'''
+  def p_aliases(self, p):
+    '''aliases : alias_rule aliases
+               | empty'''
 
   def p_alias_rule(self, p):
     'alias_rule : IDENTIFIER EQUALS composite_regex SEMICOLON'
     state = self.__state
     assert not p[1] in state.aliases
     graph = p[3]
     state.aliases[p[1]] = graph
     if graph[0] == 'CLASS' or graph[0] == 'NOT_CLASS':
       classes = state.character_classes
       assert not p[1] in classes
       classes[p[1]] = TransitionKey.character_class(graph, classes)
 
+  def p_rules(self, p):
+    '''rules : state_change transition_rules rules
+             | 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,
+        '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 : transition composite_regex code
-         | transition composite_regex TRANSITION IDENTIFIER
-         | transition composite_regex TRANSITION_WITH_CODE IDENTIFIER code'''
-    transition = p[0]
-    regex = p[2]
-    rules = self.__state.rules[self.__state.current_transition]
-    if len(p) == 4:
-      rules.append(('simple', regex, None, p[3]))
-    elif len(p) == 5:
-      rules.append(('transition', regex, p[4], None))
-    elif len(p) == 6:
-      rules.append(('transition_with_code', regex, p[4], p[5]))
+    '''transition_rule : composite_regex_or_default code action
+                       | composite_regex_or_default empty action
+                       | composite_regex_or_default code empty'''
+    rules = self.__state.rules[self.__state.current_state]
+    rule = (p[1], p[2], p[3])
+    if p[1] == 'default':
+      assert not rules['default']
+      rules['default'] = rule
     else:
-      raise Exception()
+      rules['regex'].append(rule)
 
-  def p_transition(self, p):
-    '''transition : LESS_THAN IDENTIFIER GREATER_THAN'''
-                  # | empty''' TODO skipping transition without sr conflict
-    state = self.__state
-    if p[1]:
-      state.current_transition = p[2]
-    assert state.current_transition
-    if not state.current_transition in state.rules:
-      state.rules[state.current_transition] = []
-    p[0] = state.current_transition
+  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):
@@ skipping 64 matching lines @@
   __static_instance = None
   @staticmethod
   def parse(data, parser_state):
     if not RuleParser.__static_instance:
       RuleParser.__static_instance = RuleParser()
       RuleParser.__static_instance.build()
     parser = RuleParser.__static_instance
     parser.__state = parser_state
     parser.parser.parse(data, lexer=parser.lexer.lexer)
     parser.__state = None