parseHtmlEncodedChar(text);
                } else if (scanner.lookingAt(HTML_ENTITY)) {
                    parseHtmlEntity(text);
                } else {
                    text.append(scanner.getFirst());
                    scanner.next();
                }
            }

            visitor.onText(text.toString());
        }
        visitor.onEnd();
    }

	s.tr = append(s.tr, tr)
}

func (s *Stack) Next() ScanToken {
	tos := s.tr[len(s.tr)-1]
	tok := tos.Next()
	for tok == scanner.EOF && len(s.tr) > 1 {
		tos.Close()
		// Pop the topmost item from the stack and resume with the next one down.
		s.tr = s.tr[:len(s.tr)-1]
		tok = s.Next()
	}
	return tok
}

func (s *Stack) Text() string {
	return s.tr[len(s.tr)-1].Text()
}

func (s *Stack) File() string {

    // Safe because hasNext() ensures that tryToComputeNext() has put a T into `next`.
    T result = uncheckedCastNullableTToT(next);
    next = null;
    return result;
  }

  /**
   * Returns the next element in the iteration without advancing the iteration, according to the
   * contract of {@link PeekingIterator#peek()}.
   *

    assertEquals(o1, three.next().target);
    assertFalse(three.hasNext());

    three = registry.getSubscribers("");

    registry.unregister(s2);

    assertEquals(s1, three.next().target);
    assertEquals(s2, three.next().target);
    assertEquals(o1, three.next().target);
    assertFalse(three.hasNext());

    Iterator<Subscriber> two = registry.getSubscribers("");
    assertEquals(s1, two.next().target);

                    Entry<String, String> next;

                    {
                        advance();
                    }

                    private void advance() {
                        next = null;
                        while (iterator.hasNext()) {
                            Entry<Object, Object> e = iterator.next();
                            if (PropertiesAsMap.matches(e)) {

        buf.append(cause.getMessage()).append(" : [");
        SQLException next = cause.getNextException();
        while (next != null) {
            buf.append(MessageFormatter.getSimpleMessage("ECL0071", next.getMessage(), Integer.toString(next.getErrorCode()),
                    next.getSQLState())).append("], [");
            next = next.getNextException();
        }
        Throwable t = cause.getCause();

    assertEquals("Should be able to peek() at last element", "C", peekingIterator.peek());
    assertEquals(
        "Should be able to peek() last element multiple times", "C", peekingIterator.peek());
    assertEquals(
        "next() should still return last element after peeking", "C", peekingIterator.next());

    try {
      peekingIterator.peek();
      fail("Should throw exception if no next to peek()");

     */
    @Override
    public boolean hasNext () {
        return this.next != null;
    }


    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#next()
     */
    @Override
    public SmbResource next () {
        SmbResource n = this.next;
        this.next = advance();
        return n;
    }


    /**
     * {@inheritDoc}
     *

    assertEquals(0, (int) iter.next());

    // verify idempotence of hasNext()
    assertTrue(iter.hasNext());
    assertTrue(iter.hasNext());
    assertTrue(iter.hasNext());
    assertEquals(1, (int) iter.next());

    assertFalse(iter.hasNext());

    // Make sure computeNext() doesn't get invoked again
    assertFalse(iter.hasNext());

    try {
      iter.next();
      fail("no exception thrown");

                inSectionElements.remove();

                if (next == null) {
                    break;
                } else {
                    inSection.clear();
                    inSection.add(next);
                    heading = next;
                }
            } else {
                inSection.add(next);
            }
            next = next.nextElementSibling();
        }
    }