Experimental parser: build regex parse trees for all rules

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.yacc as yacc
 from rule_lexer import RuleLexer
 from regex_parser import RegexParser
+from nfa import NfaBuilder
 
 class RuleParser:
 
   tokens = RuleLexer.tokens
 
   def __init__(self):
     self.aliases = {
-      'eof' : "eof rule",
-      'any' : "any rule",
+      'eof' : RegexParser.parse("eof"), #RegexParser.parse("[\0]"),
+      'any' : RegexParser.parse("."),
     }
     self.current_transition = None
     self.rules = {}
 
   def p_statements(self, p):
     'statements : statement maybe_statements'
 
   def p_maybe_statement(self, p):
     '''maybe_statements : statements
                         | empty'''
@@ skipping 29 matching lines @@
     if p[1]:
       self.current_transition = p[2]
     assert self.current_transition
     if not self.current_transition in self.rules:
       self.rules[self.current_transition] = []
     p[0] = self.current_transition
 
   def p_composite_regex(self, p):
     '''composite_regex : regex_parts OR regex_parts
                        | regex_parts'''
-    if p[len(p)-1]:
-      p[0] = p[1:]
+    if len(p) == 2:
+      p[0] = p[1]
     else:
-      p[0] = p[1:-1]
+      p[0] = NfaBuilder.or_graphs([p[1], p[3]])
+    # NfaBuilder().nfa(p[0])
 
   def p_regex_parts(self, p):
     '''regex_parts : regex_part
                    | regex_part regex_parts'''
-    p[0] = p[1:]
+    p[0] = NfaBuilder.cat_graphs(p[1:])
 
   def p_regex_part(self, p):
     '''regex_part : LEFT_PARENTHESIS composite_regex RIGHT_PARENTHESIS modifier
                   | regex_string_literal modifier
                   | regex_class modifier
                   | regex modifier
                   | regex_alias modifier'''
-    if p[len(p)-1]:
-      p[0] = p[1:]
+    modifier = p[len(p)-1]
+    graph = p[2] if len(p) == 5 else p[1]
+    if modifier:
+      p[0] = NfaBuilder.apply_modifier(modifier, graph)
     else:
-      p[0] = p[1:-1]
+      p[0] = graph
 
   def p_regex_string_literal(self, p):
     'regex_string_literal : STRING'
     string = p[1][1:-1]
-    for c in "\+?|*[]()":
+    for c in "\+?*|.[](){}":
       string = string.replace(c, "\\" + c)
     p[0] = RegexParser.parse(string)
 
   def p_regex(self, p):
     'regex : REGEX'
     p[0] = RegexParser.parse(p[1][1:-1])
 
   def p_regex_class(self, p):
     'regex_class : CHARACTER_CLASS_REGEX'
     p[0] = RegexParser.parse(p[1])
@@ skipping 26 matching lines @@
   def p_error(self, p):
     raise Exception("Syntax error in input '%s'" % p)
 
   def build(self, **kwargs):
     self.parser = yacc.yacc(module=self, debug=0, write_tables=0, **kwargs)
     self.lexer = RuleLexer()
     self.lexer.build(**kwargs)
 
   def parse(self, data):
     return self.parser.parse(data, lexer=self.lexer.lexer)