docs: private void parseLastLocationStep(String selector,
                                       int start )
      throws InvalidXPathSyntaxException
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        tc.entry(cclass,
                 "parseLastLocationStep",
                 "selector: " + selector + ", start: " + start); 
      int stepStart = start;
      int stepEnd = selector.length();
      int posOpenBracket = selector.indexOf("[", start);
      
      String remnant = null;
      String fullRemnant = null;
  
      // This is the final location step, bump the counter
      locationStep++;
      
      if(posOpenBracket > stepEnd || posOpenBracket == -1)
      {
        // Set posOpenBracket to avoid further processing
        posOpenBracket = -1;
        // No brackets so the remnant is the whole of the location step
        remnant = selector.substring(start,stepEnd); 
        fullRemnant = selector.substring(0, stepEnd);
           
      }
  
      // Now we'll work with the brackets
      int posCloseBracket = selector.indexOf("]", start); 
      boolean wrapWholeStep = false;
      boolean foundPredicates = false;
      ArrayList<Selector> tempSelOperands = new ArrayList<Selector>();  
      
      while (posOpenBracket >= 0)
      {
        foundPredicates = true;
        if(posCloseBracket < posOpenBracket)
        {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            tc.exit(this,cclass, "parseLastLocationStep", "bracket error");   
         
          InvalidXPathSyntaxException iex = new InvalidXPathSyntaxException(selector);
          FFDC.processException(cclass,
              "com.ibm.ws.sib.matchspace.selector.impl.XPath10ParserImpl",
              iex,
              "1:497:1.16"); 
          
          throw iex;
        }
        else
        {
          // The full name of the selector so far. The full name is used in position assignment when
          // determining uniqueness of names. Only a full name will do.
          String full = selector.substring(0,posOpenBracket);
          // Factor out the location step first but be careful we may have a predicate
          if(start != posOpenBracket)
          {
            // Go ahead and deal with the location step
            String step = selector.substring(start,posOpenBracket);
            // Add an IdentifierImpl for the location step to the array list
            // N.B. "false" cos we've bumped the location step already
            tempSelOperands.add(createIdentifierForSubExpression(step, full, false, false)); 
          }
          
          // Now parse the predicate
          String predicate = selector.substring(posOpenBracket + 1,posCloseBracket);
          Selector parsedPredicate = parsePredicate(predicate, full);
          
          // Check whether we were able to parse
          if(parsedPredicate == null)
          {
            // Unable to parse the expression, so we'll wrap the whole step
  //          tempSelOperands.add(createIdentifierForSubExpression(predicate, false));
            wrapWholeStep = true;
            break;
          }
          else
          {
            // we were able to parse the expression with the MatchParser
            parsedPredicate.setExtended();
            tempSelOperands.add(parsedPredicate);
          }       
        }
          
        // Move to beyond the close bracket
        start = posCloseBracket+1;
        //Are there any more brackets?
        posOpenBracket = selector.indexOf("[", start);
        posCloseBracket = selector.indexOf("]", start); 
        
        // Have we found the last bracket in this location step?
        if(posOpenBracket > stepEnd || posOpenBracket == -1)
        {
          // Set posOpenBracket to avoid further processing
          posOpenBracket = -1;
          
          // Set up the remnant
          if(start < stepEnd)
          {
            remnant = selector.substring(start,stepEnd);
            fullRemnant = selector.substring(0, stepEnd);
          }
        }
      } // eof while
  
      if(foundPredicates)
      {
        // If we determined that we cannot parse this location step, then wrap it
        if(wrapWholeStep)
        {
          remnant = null;
          wrapLastLocationStep(selector, stepStart, false);
        }
        else
        {
          // PostProcessing here
          selOperands.addAll(tempSelOperands);
        }
      }
      
      // Process the remnant
      if(remnant != null)
      {
        Selector parsedPredicate = parsePredicate(remnant, fullRemnant);
        // Check whether we were able to parse
        if(parsedPredicate == null)
        {
          // Unable to parse the expression, so we'll wrap it
          selOperands.add(createIdentifierForSubExpression(remnant, fullRemnant, false, true));
        }
        else
        {
          // we were able to parse the expression with the MatchParser
          parsedPredicate.setExtended();
          selOperands.add(parsedPredicate);
        }                
      }
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        tc.exit(this,cclass, "parseLastLocationStep");     
    }