/*
 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
 */
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.sun.org.apache.xerces.internal.xpointer;

import java.util.HashMap;

import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;
import com.sun.org.apache.xerces.internal.util.SymbolTable;
import com.sun.org.apache.xerces.internal.util.XMLChar;
import com.sun.org.apache.xerces.internal.xni.Augmentations;
import com.sun.org.apache.xerces.internal.xni.QName;
import com.sun.org.apache.xerces.internal.xni.XMLAttributes;
import com.sun.org.apache.xerces.internal.xni.XNIException;
import com.sun.org.apache.xerces.internal.xni.parser.XMLErrorHandler;


Implements the XPointerPart interface for element() scheme specific processing.

@xerces.internal
/**
 * <p>
 * Implements the XPointerPart interface for element() scheme specific processing.
 * </p>
 *
 * @xerces.internal
 *
 */
final class ElementSchemePointer implements XPointerPart {

    // Fields

    // The Scheme Name i.e element
    private String fSchemeName;

    // The scheme Data
    private String fSchemeData;

    // The scheme Data & child sequence
    private String fShortHandPointerName;

    // Should we attempt to resolve the ChildSequence from the
    // current element position. If a ShortHand Pointer is present
    // attempt to resolve relative to the short hand pointer.
    private boolean fIsResolveElement = false;

    // Has the element been found
    private boolean fIsElementFound = false;

    // Was only an empty element found
    private boolean fWasOnlyEmptyElementFound = false;

    // If a shorthand pointer is present and resolved
    boolean fIsShortHand = false;

    // The depth at which the element was found
    int fFoundDepth = 0;

    // The XPointer element child sequence
    private int fChildSequence[];

    // The current child position
    private int fCurrentChildPosition = 1;

    // The current child depth
    private int fCurrentChildDepth = 0;

    // The current element's child sequence
    private int fCurrentChildSequence[];;

    // Stores if the Fragment was resolved by the pointer
    private boolean fIsFragmentResolved = false;

    // Stores if the Fragment was resolved by the pointer
    private ShortHandPointer fShortHandPointer;

    // The XPointer Error reporter
    protected XMLErrorReporter fErrorReporter;

    // The XPointer Error Handler
    protected XMLErrorHandler fErrorHandler;

    //
    private SymbolTable fSymbolTable;

    // ************************************************************************
    // Constructors
    // ************************************************************************
    public ElementSchemePointer() {
    }

    public ElementSchemePointer(SymbolTable symbolTable) {
        fSymbolTable = symbolTable;
    }

    public ElementSchemePointer(SymbolTable symbolTable,
            XMLErrorReporter errorReporter) {
        fSymbolTable = symbolTable;
        fErrorReporter = errorReporter;
    }

    // ************************************************************************
    // XPointerPart implementation
    // ************************************************************************

    
Parses the XPointer expression and tokenizes it into Strings
delimited by whitespace.
See Also:
parseXPointer.parseXPointer(String)/**
     * Parses the XPointer expression and tokenizes it into Strings
     * delimited by whitespace.
     *
     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#parseXPointer(java.lang.String)
     */
    public void parseXPointer(String xpointer) throws XNIException {

        //
        init();

        // tokens
        final Tokens tokens = new Tokens(fSymbolTable);

        // scanner
        Scanner scanner = new Scanner(fSymbolTable) {
            protected void addToken(Tokens tokens, int token)
                    throws XNIException {
                if (token == Tokens.XPTRTOKEN_ELEM_CHILD
                        || token == Tokens.XPTRTOKEN_ELEM_NCNAME) {
                    super.addToken(tokens, token);
                    return;
                }
                reportError("InvalidElementSchemeToken", new Object[] { tokens
                        .getTokenString(token) });
            }
        };

        // scan the element() XPointer expression
        int length = xpointer.length();
        boolean success = scanner.scanExpr(fSymbolTable, tokens, xpointer, 0,
                length);

        if (!success) {
            reportError("InvalidElementSchemeXPointer",
                    new Object[] { xpointer });
        }

        // Initialize a temp arrays to the size of token count which should
        // be atleast twice the size of child sequence, to hold the ChildSequence.
        int tmpChildSequence[] = new int[tokens.getTokenCount() / 2 + 1];

        // the element depth
        int i = 0;

        // Traverse the scanned tokens
        while (tokens.hasMore()) {
            int token = tokens.nextToken();

            switch (token) {
            case Tokens.XPTRTOKEN_ELEM_NCNAME: {
                // Note:  Only a single ShortHand pointer can be present

                // The shortHand name
                token = tokens.nextToken();
                fShortHandPointerName = tokens.getTokenString(token);

                // Create a new ShortHandPointer
                fShortHandPointer = new ShortHandPointer(fSymbolTable);
                fShortHandPointer.setSchemeName(fShortHandPointerName);

                break;
            }
            case Tokens.XPTRTOKEN_ELEM_CHILD: {
                tmpChildSequence[i] = tokens.nextToken();
                i++;

                break;
            }
            default:
                reportError("InvalidElementSchemeXPointer",
                        new Object[] { xpointer });
            }
        }

        // Initialize the arrays to the number of elements in the ChildSequence.
        fChildSequence = new int[i];
        fCurrentChildSequence = new int[i];
        System.arraycopy(tmpChildSequence, 0, fChildSequence, 0, i);

    }

    
Returns the scheme name i.e element
See Also:
getSchemeName.getSchemeName()/**
     * Returns the scheme name i.e element
     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#getSchemeName()
     */
    public String getSchemeName() {
        return fSchemeName;
    }

    
Returns the scheme data
See Also:
getSchemeData.getSchemeData()/**
     * Returns the scheme data
     *
     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#getSchemeData()
     */
    public String getSchemeData() {
        return fSchemeData;
    }

    
Sets the scheme name
See Also:
setSchemeName.setSchemeName(String)/**
     * Sets the scheme name
     *
     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#setSchemeName(java.lang.String)
     */
    public void setSchemeName(String schemeName) {
        fSchemeName = schemeName;

    }

    
Sets the scheme data
See Also:
setSchemeData.setSchemeData(String)/**
     * Sets the scheme data
     *
     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#setSchemeData(java.lang.String)
     */
    public void setSchemeData(String schemeData) {
        fSchemeData = schemeData;
    }

    
Responsible for resolving the element() scheme XPointer.  If a ShortHand
Pointer is present and it is successfully resolved and if a child
sequence is present, the child sequence is resolved relative to it.
See Also:
com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#resolveXPointer(com.sun.org.apache.xerces.internal.xni.QName, com.sun.org.apache.xerces.internal.xni.XMLAttributes, com.sun.org.apache.xerces.internal.xni.Augmentations, int event)/**
     * Responsible for resolving the element() scheme XPointer.  If a ShortHand
     * Pointer is present and it is successfully resolved and if a child
     * sequence is present, the child sequence is resolved relative to it.
     *
     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#resolveXPointer(com.sun.org.apache.xerces.internal.xni.QName, com.sun.org.apache.xerces.internal.xni.XMLAttributes, com.sun.org.apache.xerces.internal.xni.Augmentations, int event)
     */
    public boolean resolveXPointer(QName element, XMLAttributes attributes,
            Augmentations augs, int event) throws XNIException {

        boolean isShortHandPointerResolved = false;

        // if a ChildSequence exisits, resolve child elements

        // if an element name exists
        if (fShortHandPointerName != null) {
            // resolve ShortHand Pointer
            isShortHandPointerResolved = fShortHandPointer.resolveXPointer(
                    element, attributes, augs, event);
            if (isShortHandPointerResolved) {
                fIsResolveElement = true;
                fIsShortHand = true;
            } else {
                fIsResolveElement = false;
            }
        } else {
            fIsResolveElement = true;
        }

        // Added here to skip the ShortHand pointer corresponding to
        // an element if one exisits and start searching from its child
        if (fChildSequence.length > 0) {
            fIsFragmentResolved = matchChildSequence(element, event);
        } else if (isShortHandPointerResolved && fChildSequence.length <= 0) {
            // if only a resolved shorthand pointer exists
            fIsFragmentResolved = isShortHandPointerResolved;
        } else {
            fIsFragmentResolved = false;
        }

        return fIsFragmentResolved;
    }

    
Matches the current element position in the document tree with the
element position specified in the element XPointer scheme.
Params:
event – 
Returns:
boolean - true if the current element position in the document
tree matches theelement position specified in the element XPointer
scheme./**
     * Matches the current element position in the document tree with the
     * element position specified in the element XPointer scheme.
     *
     * @param event
     * @return boolean - true if the current element position in the document
     * tree matches theelement position specified in the element XPointer
     * scheme.
     */
    protected boolean matchChildSequence(QName element, int event)
            throws XNIException {

        // need to resize fCurrentChildSequence
        if (fCurrentChildDepth >= fCurrentChildSequence.length) {
            int tmpCurrentChildSequence[] = new int[fCurrentChildSequence.length];
            System.arraycopy(fCurrentChildSequence, 0, tmpCurrentChildSequence,
                    0, fCurrentChildSequence.length);

            // Increase the size by a factor of 2 (?)
            fCurrentChildSequence = new int[fCurrentChildDepth * 2];
            System.arraycopy(tmpCurrentChildSequence, 0, fCurrentChildSequence,
                    0, tmpCurrentChildSequence.length);
        }

        //
        if (fIsResolveElement) {
            // start
            fWasOnlyEmptyElementFound = false;
            if (event == XPointerPart.EVENT_ELEMENT_START) {
                fCurrentChildSequence[fCurrentChildDepth] = fCurrentChildPosition;
                fCurrentChildDepth++;

                // reset the current child position
                fCurrentChildPosition = 1;

                //if (!fSchemeNameFound) {
                if ((fCurrentChildDepth <= fFoundDepth) || (fFoundDepth == 0)) {
                    if (checkMatch()) {
                        fIsElementFound = true;
                        fFoundDepth = fCurrentChildDepth;
                    } else {
                        fIsElementFound = false;
                        fFoundDepth = 0;
                    }
                }

            } else if (event == XPointerPart.EVENT_ELEMENT_END) {
                if (fCurrentChildDepth == fFoundDepth) {
                    fIsElementFound = true;
                } else if (((fCurrentChildDepth < fFoundDepth) && (fFoundDepth != 0))
                        || ((fCurrentChildDepth > fFoundDepth) // or empty element found
                        && (fFoundDepth == 0))) {
                    fIsElementFound = false;
                }

                // reset array position of last child
                fCurrentChildSequence[fCurrentChildDepth] = 0;

                fCurrentChildDepth--;
                fCurrentChildPosition = fCurrentChildSequence[fCurrentChildDepth] + 1;

            } else if (event == XPointerPart.EVENT_ELEMENT_EMPTY) {

                fCurrentChildSequence[fCurrentChildDepth] = fCurrentChildPosition;
                fCurrentChildPosition++;

                // Donot check for empty elements if the empty element is
                // a child of a found parent element
                if (checkMatch()) {
                    if (!fIsElementFound) {
                        fWasOnlyEmptyElementFound = true;
                    } else {
                        fWasOnlyEmptyElementFound = false;
                    }
                    fIsElementFound = true;
                } else {
                    fIsElementFound = false;
                    fWasOnlyEmptyElementFound = false;
                }
            }
        }

        return fIsElementFound;
    }

    
Matches the current position of the element being visited by checking
its position and previous elements against the element XPointer expression.
If a match is found it return true else false.
Returns:
boolean/**
     * Matches the current position of the element being visited by checking
     * its position and previous elements against the element XPointer expression.
     * If a match is found it return true else false.
     *
     * @return boolean
     */
    protected boolean checkMatch() {
        // If the number of elements in the ChildSequence is greater than the
        // current child depth, there is not point in checking further
        if (!fIsShortHand) {
            // If a shorthand pointer is not present traverse the children
            // and compare
            if (fChildSequence.length <= fCurrentChildDepth + 1) {

                for (int i = 0; i < fChildSequence.length; i++) {
                    if (fChildSequence[i] != fCurrentChildSequence[i]) {
                        return false;
                    }
                }
            } else {
                return false;
            }
        } else {
            // If a shorthand pointer is present traverse the children
            // ignoring the first element of the CurrenChildSequence which
            // contains the ShortHand pointer element and compare
            if (fChildSequence.length <= fCurrentChildDepth + 1) {

                for (int i = 0; i < fChildSequence.length; i++) {
                    // ensure fCurrentChildSequence is large enough
                    if (fCurrentChildSequence.length < i + 2) {
                        return false;
                    }

                    // ignore the first element of fCurrentChildSequence
                    if (fChildSequence[i] != fCurrentChildSequence[i + 1]) {
                        return false;
                    }
                }
            } else {
                return false;
            }

        }

        return true;
    }

    
Returns true if the node matches or is a child of a matching element()
scheme XPointer.
See Also:
isFragmentResolved.isFragmentResolved()/**
     * Returns true if the node matches or is a child of a matching element()
     * scheme XPointer.
     *
     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#isFragmentResolved()
     */
    public boolean isFragmentResolved() throws XNIException {
        // Return true if the Fragment was resolved and the current Node depth
        // is greater than or equal to the depth at which the element was found
        return fIsFragmentResolved ;
    }

    
Returns true if the XPointer expression resolves to a non-element child
of the current resource fragment.
See Also:
isChildFragmentResolved.isChildFragmentResolved()/**
     * Returns true if the XPointer expression resolves to a non-element child
     * of the current resource fragment.
     *
     * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#isChildFragmentResolved()
     *
     */
    public boolean isChildFragmentResolved() {
        // if only a shorthand pointer was present
        if (fIsShortHand && fShortHandPointer != null && fChildSequence.length <= 0) {
                return fShortHandPointer.isChildFragmentResolved();
        } else {
                return fWasOnlyEmptyElementFound ? !fWasOnlyEmptyElementFound
                                : (fIsFragmentResolved && (fCurrentChildDepth >= fFoundDepth));
        }
    }

    
Reports an XPointer error
/**
         * Reports an XPointer error
         */
    protected void reportError(String key, Object[] arguments)
            throws XNIException {
        /*fErrorReporter.reportError(XPointerMessageFormatter.XPOINTER_DOMAIN,
         key, arguments, XMLErrorReporter.SEVERITY_ERROR);
         */
        throw new XNIException((fErrorReporter
                        .getMessageFormatter(XPointerMessageFormatter.XPOINTER_DOMAIN))
                                .formatMessage(fErrorReporter.getLocale(), key, arguments));
    }

    
Initializes error handling objects
/**
     * Initializes error handling objects
     */
    protected void initErrorReporter() {
        if (fErrorReporter == null) {
            fErrorReporter = new XMLErrorReporter();
        }
        if (fErrorHandler == null) {
            fErrorHandler = new XPointerErrorHandler();
        }
        fErrorReporter.putMessageFormatter(
                XPointerMessageFormatter.XPOINTER_DOMAIN,
                new XPointerMessageFormatter());
    }

    
Initializes the element scheme processor
/**
     * Initializes the element scheme processor
     */
    protected void init() {
        fSchemeName = null;
        fSchemeData = null;
        fShortHandPointerName = null;
        fIsResolveElement = false;
        fIsElementFound = false;
        fWasOnlyEmptyElementFound = false;
        fFoundDepth = 0;
        fCurrentChildPosition = 1;
        fCurrentChildDepth = 0;
        fIsFragmentResolved = false;
        fShortHandPointer = null;

        initErrorReporter();
    }

    // ************************************************************************
    // element() Scheme expression scanner
    // ************************************************************************

    
List of XPointer Framework tokens.
Author:
Neil Delima, IBM
@xerces.internal
/**
     * List of XPointer Framework tokens.
     *
     * @xerces.internal
     *
     * @author Neil Delima, IBM
     *
     */
    private final class Tokens {

        
XPointer element() scheme
[1]    ElementSchemeData    ::=    (NCName ChildSequence?) | ChildSequence
[2]    ChildSequence    ::=    ('/' [1-9] [0-9]*)+
/**
         * XPointer element() scheme
         * [1]    ElementSchemeData    ::=    (NCName ChildSequence?) | ChildSequence
         * [2]    ChildSequence    ::=    ('/' [1-9] [0-9]*)+
         */
        private static final int XPTRTOKEN_ELEM_NCNAME = 0;

        private static final int XPTRTOKEN_ELEM_CHILD = 1;

        // Token names
        private final String[] fgTokenNames = { "XPTRTOKEN_ELEM_NCNAME",
                "XPTRTOKEN_ELEM_CHILD" };

        // Token count
        private static final int INITIAL_TOKEN_COUNT = 1 << 8;

        private int[] fTokens = new int[INITIAL_TOKEN_COUNT];

        private int fTokenCount = 0;

        // Current token position
        private int fCurrentTokenIndex;

        private SymbolTable fSymbolTable;

        private HashMap<Integer, String> fTokenNames = new HashMap<>();

        
Constructor
Params:
symbolTable – SymbolTable/**
         * Constructor
         *
         * @param symbolTable SymbolTable
         */
        private Tokens(SymbolTable symbolTable) {
            fSymbolTable = symbolTable;

            fTokenNames.put(XPTRTOKEN_ELEM_NCNAME,
                    "XPTRTOKEN_ELEM_NCNAME");
            fTokenNames.put(XPTRTOKEN_ELEM_CHILD,
                    "XPTRTOKEN_ELEM_CHILD");
        }

        /*
         * Returns the token String
         * @param token The index of the token
         * @return String The token string
         */
        private String getTokenString(int token) {
            return fTokenNames.get(token);
        }

        
Add the specified string as a token
Params:
token – The token string/**
         * Add the specified string as a token
         *
         * @param token The token string
         */
        private void addToken(String tokenStr) {
            String str = fTokenNames.get(tokenStr);
            Integer tokenInt = str == null ? null : Integer.parseInt(str);
            if (tokenInt == null) {
                tokenInt = fTokenNames.size();
                fTokenNames.put(tokenInt, tokenStr);
            }
            addToken(tokenInt.intValue());
        }

        
Add the specified int token
Params:
token – The int specifying the token/**
         * Add the specified int token
         *
         * @param token The int specifying the token
         */
        private void addToken(int token) {
            try {
                fTokens[fTokenCount] = token;
            } catch (ArrayIndexOutOfBoundsException ex) {
                int[] oldList = fTokens;
                fTokens = new int[fTokenCount << 1];
                System.arraycopy(oldList, 0, fTokens, 0, fTokenCount);
                fTokens[fTokenCount] = token;
            }
            fTokenCount++;
        }

        
Resets the current position to the head of the token list.
/**
         * Resets the current position to the head of the token list.
         */
        private void rewind() {
            fCurrentTokenIndex = 0;
        }

        
Returns true if the getNextToken() method returns a valid token. /**
         * Returns true if the {@link #getNextToken()} method
         * returns a valid token.
         */
        private boolean hasMore() {
            return fCurrentTokenIndex < fTokenCount;
        }

        
Obtains the token at the current position, then advance
the current position by one.
If there's no such next token, this method throws
new XNIException("InvalidXPointerExpression");.
/**
         * Obtains the token at the current position, then advance
         * the current position by one.
         *
         * If there's no such next token, this method throws
         * <tt>new XNIException("InvalidXPointerExpression");</tt>.
         */
        private int nextToken() throws XNIException {
            if (fCurrentTokenIndex == fTokenCount)
                reportError("XPointerElementSchemeProcessingError", null);
            return fTokens[fCurrentTokenIndex++];
        }

        
Obtains the token at the current position, without advancing
the current position.
If there's no such next token, this method throws
new XNIException("InvalidXPointerExpression");.
/**
         * Obtains the token at the current position, without advancing
         * the current position.
         *
         * If there's no such next token, this method throws
         * <tt>new XNIException("InvalidXPointerExpression");</tt>.
         */
        private int peekToken() throws XNIException {
            if (fCurrentTokenIndex == fTokenCount)
                reportError("XPointerElementSchemeProcessingError", null);
            return fTokens[fCurrentTokenIndex];
        }

        
Obtains the token at the current position as a String.
If there's no current token or if the current token
is not a string token, this method throws
If there's no such next token, this method throws
new XNIException("InvalidXPointerExpression");.
/**
         * Obtains the token at the current position as a String.
         *
         * If there's no current token or if the current token
         * is not a string token, this method throws
         * If there's no such next token, this method throws
         * <tt>new XNIException("InvalidXPointerExpression");</tt>.
         */
        private String nextTokenAsString() throws XNIException {
            String s = getTokenString(nextToken());
            if (s == null)
                reportError("XPointerElementSchemeProcessingError", null);
            return s;
        }

        
Returns the number of tokens.
/**
         * Returns the number of tokens.
         *
         */
        private int getTokenCount() {
            return fTokenCount;
        }
    }

    
The XPointer expression scanner.  Scans the XPointer framework expression.
@xerces.internal
/**
     *
     * The XPointer expression scanner.  Scans the XPointer framework expression.
     *
     * @xerces.internal
     *
     */
    private class Scanner {

        
7-bit ASCII subset
 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
 0,  0,  0,  0,  0,  0,  0,  0,  0, HT, LF,  0,  0, CR,  0,  0,  // 0
 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 1
SP,  !,  ",  #,  $,  %,  &,  ',  (,  ),  *,  +,  ,,  -,  .,  /,  // 2
 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  :,  ;,  <,  =,  >,  ?,  // 3
 @,  A,  B,  C,  D,  E,  F,  G,  H,  I,  J,  K,  L,  M,  N,  O,  // 4
 P,  Q,  R,  S,  T,  U,  V,  W,  X,  Y,  Z,  [,  \,  ],  ^,  _,  // 5
 `,  a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k,  l,  m,  n,  o,  // 6
 p,  q,  r,  s,  t,  u,  v,  w,  x,  y,  z,  {,  |,  },  ~, DEL  // 7
/**
         * 7-bit ASCII subset
         *
         *  0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
         *  0,  0,  0,  0,  0,  0,  0,  0,  0, HT, LF,  0,  0, CR,  0,  0,  // 0
         *  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 1
         * SP,  !,  ",  #,  $,  %,  &,  ',  (,  ),  *,  +,  ,,  -,  .,  /,  // 2
         *  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  :,  ;,  <,  =,  >,  ?,  // 3
         *  @,  A,  B,  C,  D,  E,  F,  G,  H,  I,  J,  K,  L,  M,  N,  O,  // 4
         *  P,  Q,  R,  S,  T,  U,  V,  W,  X,  Y,  Z,  [,  \,  ],  ^,  _,  // 5
         *  `,  a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k,  l,  m,  n,  o,  // 6
         *  p,  q,  r,  s,  t,  u,  v,  w,  x,  y,  z,  {,  |,  },  ~, DEL  // 7
         */
        private static final byte CHARTYPE_INVALID = 0, // invalid XML characters, control characters and 7F
                CHARTYPE_OTHER = 1, // A valid XML character (possibly invalid NCNameChar) that does not fall in one of the other categories
                CHARTYPE_MINUS = 2, // '-' (0x2D)
                CHARTYPE_PERIOD = 3, // '.' (0x2E)
                CHARTYPE_SLASH = 4, // '/' (0x2F)
                CHARTYPE_DIGIT = 5, // '0'-'9' (0x30 to 0x39)
                CHARTYPE_LETTER = 6, // 'A'-'Z' or 'a'-'z' (0x41 to 0x5A and 0x61 to 0x7A)
                CHARTYPE_UNDERSCORE = 7, // '_' (0x5F)
                CHARTYPE_NONASCII = 8; // Non-ASCII Unicode codepoint (>= 0x80)

        private final byte[] fASCIICharMap = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
                0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 4, 5, 5, 5, 5, 5,
                5, 5, 5, 5, 5, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 1, 1, 1, 1,
                7, 1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1 };

        /**
         * Symbol literals
         */

        //
        // Data
        //
        
Symbol table. /** Symbol table. */
        private SymbolTable fSymbolTable;

        //
        // Constructors
        //

        
Constructs an XPath expression scanner.
Params:
symbolTable – SymbolTable/**
         * Constructs an XPath expression scanner.
         *
         * @param symbolTable SymbolTable
         */
        private Scanner(SymbolTable symbolTable) {
            // save pool and tokens
            fSymbolTable = symbolTable;

        } // <init>(SymbolTable)

        
Scans the XPointer Expression
/**
         * Scans the XPointer Expression
         *
         */
        private boolean scanExpr(SymbolTable symbolTable, Tokens tokens,
                String data, int currentOffset, int endOffset)
                throws XNIException {

            int ch;
            int nameOffset;
            String nameHandle = null;

            while (true) {
                if (currentOffset == endOffset) {
                    break;
                }

                ch = data.charAt(currentOffset);
                byte chartype = (ch >= 0x80) ? CHARTYPE_NONASCII
                        : fASCIICharMap[ch];

                //
                // [1]    ElementSchemeData    ::=    (NCName ChildSequence?) | ChildSequence
                // [2]    ChildSequence    ::=    ('/' [1-9] [0-9]*)+
                //

                switch (chartype) {

                case CHARTYPE_SLASH:
                    // if last character is '/', break and report an error
                    if (++currentOffset == endOffset) {
                        return false;
                    }

                    addToken(tokens, Tokens.XPTRTOKEN_ELEM_CHILD);
                    ch = data.charAt(currentOffset);

                    // ChildSequence    ::=    ('/' [1-9] [0-9]*)+
                    int child = 0;
                    while (ch >= '0' && ch <= '9') {
                        child = (child * 10) + (ch - '0');
                        if (++currentOffset == endOffset) {
                            break;
                        }
                        ch = data.charAt(currentOffset);
                    }

                    // An invalid child sequence character
                    if (child == 0) {
                        reportError("InvalidChildSequenceCharacter",
                                new Object[] { (char) ch });
                        return false;
                    }

                    tokens.addToken(child);

                    break;

                case CHARTYPE_DIGIT:
                case CHARTYPE_LETTER:
                case CHARTYPE_MINUS:
                case CHARTYPE_NONASCII:
                case CHARTYPE_OTHER:
                case CHARTYPE_PERIOD:
                case CHARTYPE_UNDERSCORE:
                    // Scan the ShortHand Pointer NCName
                    nameOffset = currentOffset;
                    currentOffset = scanNCName(data, endOffset, currentOffset);

                    if (currentOffset == nameOffset) {
                        //return false;
                        reportError("InvalidNCNameInElementSchemeData",
                                new Object[] { data });
                        return false;
                    }

                    if (currentOffset < endOffset) {
                        ch = data.charAt(currentOffset);
                    } else {
                        ch = -1;
                    }

                    nameHandle = symbolTable.addSymbol(data.substring(
                            nameOffset, currentOffset));
                    addToken(tokens, Tokens.XPTRTOKEN_ELEM_NCNAME);
                    tokens.addToken(nameHandle);

                    break;
                }
            }
            return true;
        }

        
Scans a NCName.
From Namespaces in XML
[5] NCName ::= (Letter | '_') (NCNameChar)*
[6] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender
Params:
data – A String containing the XPointer expression
endOffset – The int XPointer expression length
currentOffset – An int representing the current position of the XPointer expression pointer/**
         * Scans a NCName.
         * From Namespaces in XML
         * [5] NCName ::= (Letter | '_') (NCNameChar)*
         * [6] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender
         *
         * @param data A String containing the XPointer expression
         * @param endOffset The int XPointer expression length
         * @param currentOffset An int representing the current position of the XPointer expression pointer
         */
        private int scanNCName(String data, int endOffset, int currentOffset) {
            int ch = data.charAt(currentOffset);
            if (ch >= 0x80) {
                if (!XMLChar.isNameStart(ch)) {
                    return currentOffset;
                }
            } else {
                byte chartype = fASCIICharMap[ch];
                if (chartype != CHARTYPE_LETTER
                        && chartype != CHARTYPE_UNDERSCORE) {
                    return currentOffset;
                }
            }
            while (++currentOffset < endOffset) {
                ch = data.charAt(currentOffset);
                if (ch >= 0x80) {
                    if (!XMLChar.isName(ch)) {
                        break;
                    }
                } else {
                    byte chartype = fASCIICharMap[ch];
                    if (chartype != CHARTYPE_LETTER
                            && chartype != CHARTYPE_DIGIT
                            && chartype != CHARTYPE_PERIOD
                            && chartype != CHARTYPE_MINUS
                            && chartype != CHARTYPE_UNDERSCORE) {
                        break;
                    }
                }
            }
            return currentOffset;
        }

        //
        // Protected methods
        //

        
This method adds the specified token to the token list. By
default, this method allows all tokens. However, subclasses
of the XPathExprScanner can override this method in order
to disallow certain tokens from being used in the scanned
XPath expression. This is a convenient way of allowing only
a subset of XPath.
/**
         * This method adds the specified token to the token list. By
         * default, this method allows all tokens. However, subclasses
         * of the XPathExprScanner can override this method in order
         * to disallow certain tokens from being used in the scanned
         * XPath expression. This is a convenient way of allowing only
         * a subset of XPath.
         */
        protected void addToken(Tokens tokens, int token) throws XNIException {
            tokens.addToken(token);
        } // addToken(int)

    } // class Scanner

}