code: def push_rule(self, name):
          
  
          # Verify that we haven't been evaluating the rule already;
          # this is to prohibit recursive rules from locking us up...
          if name in self._name:
              raise PolicyException(
                  "Rule recursion detected; invocation chain: %s -> %s" %
                  (' -> '.join(self._name), name))
  
          # Save the name temporarily, and set up the program counter
          # and step
          self._name.append(name)
          self._pc.append(0)
          self._step.append(1)
          try:
              yield
          except Exception as exc:
              exc_info = sys.exc_info()
  
              # Report only if we haven't reported it yet
              if not self.reported:
                  # Get the logger and emit a log message
                  log = logging.getLogger('policies')
                  log.warn("Exception raised while evaluating rule %r: %s" %
                           (name, exc))
                  self.reported = True
  
              six.reraise(*exc_info)
          finally:
              # Pop the name off the stack of names and restore program
              # counter and step
              self._name.pop()
              self._pc.pop()
              self._step.pop()
docs: Allow one rule to be evaluated in the context of another.
          This allows keeping track of the rule names during nested rule
          evaluation.
  
          :param name: The name of the nested rule to be evaluated.
  
          :returns: A context manager, suitable for use with the
                    ``with`` statement.  No value is generated.