docs: public void get(
      Object rootVal,
      MatchSpaceKey msg,
      EvalCache cache,
      Object contextValue,
      SearchResults result)
      throws MatchingException, BadMessageFormatMatchingException
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        tc.entry(
            this,cclass,
          "get",
          "msg: " + msg + ", result: " + result);
  
      // type never used so removed
      //int type;
  
      List[] v = alwaysMatch.lists;
      if (v.length > 0)
        result.addObjects(v);
  
      if (msg != null)
      {
        int numExpr = roots.size();
  
        for (int current = 0; current < numExpr; current++)
        {
          Boolean res = null;
  
          // May need to call MFP multiple times, if our context has multiple nodes
          if(contextValue != null)
          {
            // Currently this must be a list of nodes
            if (contextValue instanceof SetValEvaluationContext)
            {
              SetValEvaluationContext evalContext = (SetValEvaluationContext)contextValue;
              
              // Get the node list
              ArrayList wrappedParentList = evalContext.getWrappedNodeList(); 
              // If the list is empty, then we have yet to get the document root
              if(wrappedParentList.isEmpty())
              {
          	    //Set up a root (document) context for evaluation
              	Object docRoot = Matching.getEvaluator().getDocumentRoot(msg);
                  
                  // Create an object to hold the wrapped node
                  WrappedNodeResults wrapper = new WrappedNodeResults(docRoot);
                  // Set the root into the evaluation context
                  evalContext.addNode(wrapper);
              }
              
              // Iterate over the nodes
              Iterator iter = wrappedParentList.iterator();
  
              while(iter.hasNext())
              {
                WrappedNodeResults nextWrappedNode = (WrappedNodeResults)iter.next();       
                Object nextNode = nextWrappedNode.getNode();
                  
                  
                // If no cached value we'll need to call MFP
                //TODO: No caching here
  
                // Call MFP to get the results for this node
                res = 
                  (Boolean) Matching.
                    getEvaluator().
                      eval((Selector) roots.get(current),
                           msg,
                           cache,
                           nextNode,
                           true); // Permissive is true  
  
                if(res !=null && res.booleanValue())
                {
                  break;
                }     
       
              } // eof while
            } // eof instanceof XPathEvaluationContext
          }
          else
          {
            res = (Boolean) Matching.getEvaluator().eval(
                (Selector) roots.get(current),
                msg,
                cache,
                contextValue,
                false);            
          }
          
          if (res != null && res.booleanValue())
          {
            MatchTargetTypeList tlist = (MatchTargetTypeList) objs.get(current);
            v = tlist.lists;
            if (v.length > 0)
              result.addObjects(v);
          }
        }
      }
      // ContinueBranch has to be last to treat this node as if it was at the end of
      // a long chain of *, or a #.
      super.get(null, msg, cache, contextValue, result);
  
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        tc.exit(this,cclass, "get");
  
    }