Experimental parser: unify parser construction

tools/lexer_generator/regex_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 13 matching lines @@
 # 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 types import ListType, TupleType
 from regex_lexer import RegexLexer
 from action import Term
 
+class ParserBuilder:
+
+  class Logger(object):
+    def debug(self,msg,*args,**kwargs):
+      pass
+
+    def info(self,msg,*args,**kwargs):
+      pass
+
+    def warning(self,msg,*args,**kwargs):
+      pass
+      # assert False, "warning: "+ (msg % args) + "\n"
+
+    def error(self,msg,*args,**kwargs):
+      assert False, "error: "+ (msg % args) + "\n"
+
+  __static_instances = {}
+  @staticmethod
+  def parse(
+      string, name, new_lexer, new_parser, preparse = None, postparse = None):
+    if not name in ParserBuilder.__static_instances:
+      logger = ParserBuilder.Logger()
+      lexer_instance = new_lexer()
+      lexer_instance.lex = lex.lex(module=lexer_instance)
+      instance = new_parser()
+      instance.yacc = yacc.yacc(
+        module=instance, debug=True, write_tables=0,
+        debuglog=logger, errorlog=logger)
+      ParserBuilder.__static_instances[name] = (lexer_instance, instance)
+    (lexer_instance, instance) = ParserBuilder.__static_instances[name]
+    if preparse:
+      preparse(instance)
+    try:
+      return_value = instance.yacc.parse(string, lexer=lexer_instance.lex)
+    except Exception:
+      del ParserBuilder.__static_instances[name]
+      raise
+    if postparse:
+      postparse(instance)
+    return return_value
+
 def build_escape_map(chars):
   def add_escape(d, char):
     d['\\' + char] = char
     return d
   return reduce(add_escape, chars,
     {'\\t' : '\t', '\\r' : '\r', '\\n' : '\n', '\\v' : '\v', '\\f' : '\f'})
 
 class RegexLexer:
 
   tokens = (
@@ skipping 44 matching lines @@
   t_ONE_OR_MORE = r'\+'
   t_ZERO_OR_MORE = r'\*'
   t_ZERO_OR_ONE = r'\?'
 
   t_ANY = r'\.'
 
   t_LITERAL = r'.'
 
   def t_CLASS_BEGIN(self, t):
     r'\['
-    self.lexer.push_state('class')
+    self.lex.push_state('class')
     return t
 
   def t_class_CLASS_END(self, t):
     r'\]'
-    self.lexer.pop_state()
+    self.lex.pop_state()
     return t
 
   t_class_RANGE = '-'
   t_class_NOT = '\^'
   t_class_CHARACTER_CLASS = r':\w+:'
 
   def t_class_CLASS_LITERAL_AS_OCTAL(self, t):
     r'\\\d+'
     return t
 
   __escaped_class_literals = build_escape_map("^[]-:\\")
 
   def t_class_ESCAPED_CLASS_LITERAL(self, t):
     r'\\.'
     t.type = 'CLASS_LITERAL'
     t.value = RegexLexer.__escaped_class_literals[t.value]
     return t
 
   t_class_CLASS_LITERAL = r'[\w *$_+\'\"/]'
 
   def t_REPEAT_BEGIN(self, t):
     r'\{'
-    self.lexer.push_state('repeat')
+    self.lex.push_state('repeat')
     return t
 
   def t_repeat_REPEAT_END(self, t):
     r'\}'
-    self.lexer.pop_state()
+    self.lex.pop_state()
     return t
 
   t_repeat_NUMBER = r'[0-9]+'
   t_repeat_COMMA = r','
 
   t_ANY_ignore  = '\n'
 
   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 RegexParser:
 
   tokens = RegexLexer.tokens
 
   token_map = {
     '+': 'ONE_OR_MORE',
     '?': 'ZERO_OR_ONE',
     '*': 'ZERO_OR_MORE',
     '|': 'OR',
     '.': 'ANY',
@@ skipping 106 matching lines @@
     'empty :'
 
   def p_error(self, p):
     raise Exception("Syntax error in input '%s'" % str(p))
 
   @staticmethod
   def __cat(left, right):
     assert left
     return left if not right else Term('CAT', left, right)
 
-  def build(self, **kwargs):
-    self.parser = yacc.yacc(module=self, debug=0, write_tables=0, **kwargs)
-    self.lexer = RegexLexer()
-    self.lexer.build(**kwargs)
-
-  __static_instance = None
   @staticmethod
-  def parse(data):
-    parser = RegexParser.__static_instance
-    if not parser:
-      parser = RegexParser()
-      parser.build()
-      RegexParser.__static_instance = parser
-    try:
-      return parser.parser.parse(data, lexer=parser.lexer.lexer)
-    except Exception:
-      RegexParser.__static_instance = None
-      raise
+  def parse(string):
+    new_lexer = lambda: RegexLexer()
+    new_parser = lambda: RegexParser()
+    return ParserBuilder.parse(string, "RegexParser", new_lexer, new_parser)