private void  consumeFirst()
        {
            consume();             // get first token of input stream

            // Handle situation where hidden or discarded tokens
            // appear first in input stream
            CommonHiddenStreamToken p = null;

            // while hidden or discarded scarf tokens
            while (hideMask.member(LA(1).Type) || discardMask.member(LA(1).Type))
            {
                if (hideMask.member(LA(1).Type))
                {
                    if (p == null)
                    {
                        p = LA(1);
                    }
                    else
                    {
                        p.setHiddenAfter(LA(1));
                        LA(1).setHiddenBefore(p);                         // double-link
                        p = LA(1);
                    }
                    lastHiddenToken = p;
                    if (firstHidden == null)
                    {
                        firstHidden = p;                         // record hidden token if first
                    }
                }
                consume();
            }
        }
        /*Return the next monitored token.
         *  Test the token following the monitored token.
         *  If following is another monitored token, save it
         *  for the next invocation of nextToken (like a single
         *  lookahead token) and return it then.
         *  If following is unmonitored, nondiscarded (hidden)
         *  channel token, add it to the monitored token.
         *
         *  Note: EOF must be a monitored Token.
         */
        override public Token nextToken()
        {
            // handle an initial condition; don't want to get lookahead
            // token of this splitter until first call to nextToken
            if (LA(1) == null)
            {
                consumeFirst();
            }

            // we always consume hidden tokens after monitored, thus,
            // upon entry LA(1) is a monitored token.
            CommonHiddenStreamToken monitored = LA(1);

            // point to hidden tokens found during last invocation
            monitored.setHiddenBefore(lastHiddenToken);
            lastHiddenToken = null;

            // Look for hidden tokens, hook them into list emanating
            // from the monitored tokens.
            consume();
            CommonHiddenStreamToken p = monitored;

            // while hidden or discarded scarf tokens
            while (hideMask.member(LA(1).Type) || discardMask.member(LA(1).Type))
            {
                if (hideMask.member(LA(1).Type))
                {
                    // attach the hidden token to the monitored in a chain
                    // link forwards
                    p.setHiddenAfter(LA(1));
                    // link backwards
                    if (p != monitored)
                    {
                        //hidden cannot point to monitored tokens
                        LA(1).setHiddenBefore(p);
                    }
                    p = (lastHiddenToken = LA(1));
                }
                consume();
            }
            return(monitored);
        }