Experimental parser: unify parser construction

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 10 matching lines @@
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import ply.lex as lex
 import ply.yacc as yacc
 from action import Term, Action
-from regex_parser import RegexParser
+from regex_parser import RegexParser, ParserBuilder
 from nfa_builder import NfaBuilder
 from dfa import Dfa
 from dfa_optimizer import DfaOptimizer
 from transition_keys import TransitionKey, KeyEncoding
 
 class RuleLexer:
 
   tokens = (
     'DEFAULT_ACTION',
     'EPSILON',
@@ skipping 47 matching lines @@
   t_EQUALS = '='
   t_LEFT_PARENTHESIS = r'\('
   t_RIGHT_PARENTHESIS = r'\)'
   t_GRAPH_OPEN = '<<'
   t_GRAPH_CLOSE = '>>'
   t_SEMICOLON = ';'
   t_ACTION_OPEN = '<'
   t_ACTION_CLOSE = '>'
   t_COMMA = ','
 
-  def t_LEFT_BRACKET(self, t):
-    r'{'
-    self.lexer.push_state('code')
-    self.nesting = 1
-    return t
-
   def t_ANY_error(self, t):
     raise Exception("Illegal character '%s'" % t.value[0])
 
-  def build(self, **kwargs):
-    self.lexer = lex.lex(module=self, **kwargs)
-
 class RuleParserState:
 
   def __init__(self, encoding):
     self.aliases = {}
     self.character_classes = {}
     self.current_state = None
     self.rules = {}
     self.transitions = set()
     self.encoding = encoding
 
@@ skipping 169 matching lines @@
       p[0] = NfaBuilder.apply_modifier(modifier, term)
     else:
       p[0] = term
 
   def p_regex_string_literal(self, p):
     'regex_string_literal : STRING'
     string = p[1][1:-1]
     escape_char = lambda string, char: string.replace(char, "\\" + char)
     string = reduce(escape_char, "+?*|.[](){}", string).replace("\\\"", "\"")
     p[0] = RegexParser.parse(string)
+
   def p_regex(self, p):
     'regex : REGEX'
     string = p[1][1:-1].replace("\\/", "/")
     p[0] = RegexParser.parse(string)
 
   def p_regex_class(self, p):
     'regex_class : CHARACTER_CLASS_REGEX'
     p[0] = RegexParser.parse(p[1])
 
   def p_regex_alias(self, p):
     'regex_alias : IDENTIFIER'
     p[0] = self.__state.aliases[p[1]]
 
   def p_modifier(self, p):
     '''modifier : PLUS
                 | QUESTION_MARK
                 | STAR
                 | empty'''
     p[0] = p[1]
 
   def p_empty(self, p):
     'empty :'
 
   def p_error(self, p):
     raise Exception("Syntax error in input '%s'" % str(p))
 
-  def build(self, **kwargs):
-    self.parser = yacc.yacc(module=self, debug=0, write_tables=0, **kwargs)
-    self.lexer = RuleLexer()
-    self.lexer.build(**kwargs)
-
-  __static_instance = None
   @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:
-      RuleParser.__static_instance = None
-      raise
-    parser.__state = None
+  def parse(string, parser_state):
+    new_lexer = lambda: RuleLexer()
+    new_parser = lambda: RuleParser()
+    def preparse(parser):
+      parser.__state = parser_state
+    def postparse(parser):
+      parser.__state = None
+    return ParserBuilder.parse(
+      string, "RuleParser", new_lexer, new_parser, preparse, postparse)
 
 class RuleProcessor(object):
 
   def __init__(self, string, encoding_name):
     self.__automata = {}
     self.__default_action = None
     self.__parser_state = RuleParserState(KeyEncoding.get(encoding_name))
     RuleParser.parse(string, self.__parser_state)
     self.__process_parser_state()
 
@@ skipping 58 matching lines @@
     for tree_name, v in parser_state.rules.items():
       assert v['trees'], "lexer state %s is empty" % tree_name
       rule_map[tree_name] = NfaBuilder.or_terms(v['trees'])
     # build the automata
     for name, tree in rule_map.items():
       self.__automata[name] = RuleProcessor.Automata(
         parser_state.encoding, parser_state.character_classes, rule_map, name)
     # process default_action
     default_action = parser_state.rules['default']['default_action']
     self.__default_action = Action(Term.empty_term(), default_action)