Experimental parser: use sentinal values for 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 68 matching lines @@
     '''rules : state_change transition_rules rules
              | empty'''
 
   def p_state_change(self, p):
     'state_change : GRAPH_OPEN IDENTIFIER GRAPH_CLOSE'
     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,
+        'default_action': Term.empty_term(),
         'uniques' : {},
         '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 action
                        | DEFAULT_ACTION default_action
                        | EOS eos
                        | CATCH_ALL action'''
     precedence = RuleParser.__rule_precedence_counter
     RuleParser.__rule_precedence_counter += 1
     action = p[2]
     (entry_action, match_action, transition) = action
     if transition and not transition in self.__keyword_transitions:
       assert not transition == 'default', "can't append default graph"
       self.__state.transitions.add(transition)
     rules = self.__state.rules[self.__state.current_state]
     if p[1] == 'default_action':
       assert self.__state.current_state == 'default'
       assert not rules['default_action']
-      rules['default_action'] = action
+      assert not entry_action
+      rules['default_action'] = match_action
     elif p[1] == 'eos' or p[1] == 'catch_all':
       assert p[1] not in rules['uniques']
       rules['uniques'][p[1]] = True
       rules['regex'].append((NfaBuilder.unique_key(p[1]), precedence, action))
     else:
       regex = p[1]
       rules['regex'].append((regex, precedence, action))
 
   def p_action(self, p):
     '''action : ACTION_OPEN maybe_identifier_action OR maybe_identifier_action OR maybe_transition ACTION_CLOSE'''
     p[0] = (p[2], p[4], p[6])
 
   def p_default_action(self, p):
     'default_action : ACTION_OPEN identifier_action ACTION_CLOSE'
-    p[0] = (None, p[2], None)
+    p[0] = (Term.empty_term(), p[2], None)
 
   def p_eos(self, p):
     'eos : ACTION_OPEN identifier_action ACTION_CLOSE'
-    p[0] = (None, p[2], None)
+    p[0] = (Term.empty_term(), p[2], None)
 
   def p_maybe_identifier_action(self, p):
     '''maybe_identifier_action : identifier_action
                          | empty'''
-    p[0] = p[1]
+    p[0] = p[1] if p[1] else Term.empty_term()
 
   def p_maybe_transition(self, p):
     '''maybe_transition : IDENTIFIER
                         | empty'''
     p[0] = p[1]
 
   def p_identifier_action(self, p):
     '''identifier_action : IDENTIFIER
                          | IDENTIFIER LEFT_PARENTHESIS RIGHT_PARENTHESIS
                          | IDENTIFIER LEFT_PARENTHESIS action_params RIGHT_PARENTHESIS'''
@@ skipping 156 matching lines @@
     def process(subgraph, v):
       graphs = []
       for graph, precedence, action in v['regex']:
         (entry_action, match_action, transition) = action
         if entry_action or match_action:
           action = Action(entry_action, match_action, precedence)
           graph = NfaBuilder.add_action(graph, action)
         if not transition:
           pass
         elif transition == 'continue':
-          assert not subgraph == 'default'
+          assert not subgraph == 'default', 'unimplemented'
           graph = NfaBuilder.add_continue(graph)
         else:
-          assert subgraph == 'default'
+          assert subgraph == 'default', 'unimplemented'
           graph = NfaBuilder.join_subgraph(
             graph, transition, rule_map[transition])
         graphs.append(graph)
       graph = NfaBuilder.or_graphs(graphs)
       rule_map[subgraph] = graph
     # process first the subgraphs, then the default graph
     for k, v in parser_state.rules.items():
       if k == 'default': continue
       process(k, v)
     process('default', parser_state.rules['default'])
     # build the automata
     for rule_name, graph in rule_map.items():
       self.__automata[rule_name] = RuleProcessor.Automata(builder, graph)
       self.__rule_trees[rule_name] = graph
     # process default_action
     default_action = parser_state.rules['default']['default_action']
-    self.default_action = Action(None, default_action[1]) if default_action else None
+    self.default_action = Action(Term.empty_term(), default_action)