Experimental parser: split and rename some files

tools/lexer_generator/automaton.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
 #       with the distribution.
 #     * Neither the name of Google Inc. nor the names of its
 #       contributors may be used to endorse or promote products derived
 #       from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # 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.
 
-from types import TupleType, ListType
+from types import IntType, TupleType, ListType
 from itertools import chain
-from action import Term, Action
-from transition_keys import TransitionKey
+from term import Term
+from transition_key import TransitionKey
+
+class Action(object):
+
+  __empty_action = None
+
+  @staticmethod
+  def empty_action():
+    if Action.__empty_action == None:
+      Action.__empty_action = Action(Term.empty_term(), -1)
+    return Action.__empty_action
+
+  @staticmethod
+  def dominant_action(actions):
+    dominant = Action.empty_action()
+    for action in actions:
+      if not action:
+        continue
+      if not dominant:
+        dominant = action
+        continue
+      if action.precedence() == dominant.precedence():
+        assert action.__term == dominant.__term
+      elif action.precedence() < dominant.precedence():
+        dominant = action
+    return dominant
+
+  def __init__(self, term, precedence):
+    assert isinstance(term, Term)
+    assert type(precedence) == IntType
+    assert not term or precedence >= 0, 'action must have positive precedence'
+    self.__term = term
+    self.__precedence = precedence
+
+  def name(self):
+    return self.__term.name()
+
+  def term(self):
+    return self.__term
+
+  def precedence(self):
+    return self.__precedence
+
+  def __nonzero__(self):
+    'true <==> self == empty_action'
+    return bool(self.__term)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__term == other.__term
+
+  def __str__(self):
+    return "action <%s>" % ('' if not self.__term else str(self.__term))
 
 class AutomatonState(object):
   '''A base class for dfa and nfa states.  Immutable'''
 
   __node_number_counter = 0
 
   def __init__(self):
     self.__node_number = AutomatonState.__node_number_counter
     AutomatonState.__node_number_counter += 1
 
@@ skipping 108 matching lines @@
       last_position = pos
       # lex next token
       valid_states = Automaton.__transition_states_for_char(self.start_set(), c)
       assert valid_states
     valid_states = self.__omega_closure(self.epsilon_closure(valid_states))
     action = self.dominant_action(valid_states)
     if not action:
       assert default_action
       action = default_action
     yield (action, last_position, len(string))