code: protected int getProximityPosition(int predicateIndex)
    {
      if(!isReverseAxes())
        return super.getProximityPosition(predicateIndex);
        
      // A negative predicate index seems to occur with
      // (preceding-sibling::*|following-sibling::*)/ancestor::*[position()]/*[position()]
      // -sb
      if(predicateIndex < 0)
        return -1;
        
      if (m_proximityPositions[predicateIndex] <= 0)
      {
        XPathContext xctxt = getXPathContext();
        try
        {
          OneStepIterator clone = (OneStepIterator) this.clone();
          
          int root = getRoot();
          xctxt.pushCurrentNode(root);
          clone.setRoot(root, xctxt);
  
          // clone.setPredicateCount(predicateIndex);
          clone.m_predCount = predicateIndex;
  
          // Count 'em all
          int count = 1;
          int next;
  
          while (DTM.NULL != (next = clone.nextNode()))
          {
            count++;
          }
  
          m_proximityPositions[predicateIndex] += count;
        }
        catch (CloneNotSupportedException cnse)
        {
  
          // can't happen
        }
        finally
        {
          xctxt.popCurrentNode();
        }
      }
  
      return m_proximityPositions[predicateIndex];
    }
docs: Get the current sub-context position.  In order to do the
  reverse axes count, for the moment this re-searches the axes
  up to the predicate.  An optimization on this is to cache
  the nodes searched, but, for the moment, this case is probably
  rare enough that the added complexity isn't worth it.
  
  @param predicateIndex The predicate index of the proximity position.
  
  @return The pridicate index, or -1.