libvpx: Pull from upstream

source/libvpx/examples/includes/HTML-Toc-0.91/TocGenerator.pm

Index: source/libvpx/examples/includes/HTML-Toc-0.91/TocGenerator.pm
===================================================================
--- source/libvpx/examples/includes/HTML-Toc-0.91/TocGenerator.pm	(revision 247498)
+++ source/libvpx/examples/includes/HTML-Toc-0.91/TocGenerator.pm	(working copy)
@@ -1,1793 +0,0 @@
-#=== HTML::TocGenerator =======================================================
-# function: Generate 'HTML::Toc' table of contents.
-# note:     - 'TT' is an abbrevation of 'TocToken'.
-
-
-package HTML::TocGenerator;
-
-
-use strict;
-use HTML::Parser;
-
-
-BEGIN {
-	use vars qw(@ISA $VERSION);
-
-	$VERSION = '0.91';
-
-	@ISA = qw(HTML::Parser);
-}
-
-
-	# Warnings
-use constant WARNING_NESTED_ANCHOR_PS_WITHIN_PS               => 1;
-use constant WARNING_TOC_ATTRIBUTE_PS_NOT_AVAILABLE_WITHIN_PS => 2;
-
-
-use constant TOC_TOKEN_ID       => 0;
-use constant TOC_TOKEN_INCLUDE  => 1;
-use constant TOC_TOKEN_EXCLUDE  => 2;
-use constant TOC_TOKEN_TOKENS   => 3;
-use constant TOC_TOKEN_GROUP    => 4;
-use constant TOC_TOKEN_TOC      => 5;
-
-	# Token types
-use constant TT_TAG_BEGIN                => 0;
-use constant TT_TAG_END                  => 1;
-use constant TT_TAG_TYPE_END             => 2;
-use constant TT_INCLUDE_ATTRIBUTES_BEGIN => 3;
-use constant TT_EXCLUDE_ATTRIBUTES_BEGIN => 4;
-use constant TT_INCLUDE_ATTRIBUTES_END   => 5;
-use constant TT_EXCLUDE_ATTRIBUTES_END   => 6;
-use constant TT_GROUP                    => 7;
-use constant TT_TOC                      => 8;
-use constant TT_ATTRIBUTES_TOC           => 9;
-
-
-use constant CONTAINMENT_INCLUDE => 0;
-use constant CONTAINMENT_EXCLUDE => 1;
-
-use constant TEMPLATE_ANCHOR            => '$groupId."-".$node';
-use constant TEMPLATE_ANCHOR_HREF       => 
-					'"<a href=#".' . TEMPLATE_ANCHOR . '.">"';
-use constant TEMPLATE_ANCHOR_HREF_FILE  => 
-					'"<a href=".$file."#".' . TEMPLATE_ANCHOR . '.">"';
-use constant TEMPLATE_ANCHOR_NAME       => 
-					'"<a name=".' . TEMPLATE_ANCHOR . '.">"';
-
-use constant TEMPLATE_TOKEN_NUMBER      => '"$node &nbsp"';
-
-
-use constant TT_TOKENTYPE_START        => 0;
-use constant TT_TOKENTYPE_END          => 1;
-use constant TT_TOKENTYPE_TEXT         => 2;
-use constant TT_TOKENTYPE_COMMENT      => 3;
-use constant TT_TOKENTYPE_DECLARATION  => 4;
-
-
-END {}
-
-
-#--- HTML::TocGenerator::new() ------------------------------------------------
-# function: Constructor
-
-sub new {
-		# Get arguments
-	my ($aType) = @_;
-	my $self = $aType->SUPER::new;
-		# Bias to not generate ToC
-	$self->{_doGenerateToc} = 0;
-		# Bias to not use global groups
-	$self->{_doUseGroupsGlobal} = 0;
-		# Output
-	$self->{output} = "";
-		# Reset internal variables
-	$self->_resetBatchVariables();
-
-	$self->{options} = {};
-
-	return $self;
-}  # new()
-
-
-#--- HTML::TocGenerator::_deinitializeBatch() ---------------------------------
-
-sub _deinitializeBatch() {
-		# Get arguments
-	my ($self) = @_;
-}  # _deinitializeBatch()
-
-
-#--- HTML::TocGenerator::_deinitializeExtenderBatch() -------------------------
-
-sub _deinitializeExtenderBatch() {
-		# Get arguments
-	my ($self) = @_;
-		# Do general batch deinitialization
-	$self->_deinitializeBatch();
-		# Indicate end of ToC generation
-	$self->{_doGenerateToc} = 0;
-		# Reset batch variables
-	$self->_resetBatchVariables();
-}  # _deinitializeExtenderBatch()
-
-
-#--- HTML::TocGenerator::_deinitializeGeneratorBatch() ------------------------
-
-sub _deinitializeGeneratorBatch() {
-		# Get arguments
-	my ($self) = @_;
-		# Do 'extender' batch deinitialization
-	$self->_deinitializeExtenderBatch();
-}  # _deinitializeBatchGenerator()
-
-
-#--- HTML::TocGenerator::_doesHashContainHash() -------------------------------
-# function: Determines whether hash1 matches regular expressions of hash2.
-# args:     - $aHash1
-#           - $aHash2
-#           - $aContainmentType: 0 (include) or 1 (exclude)
-# returns:  True (1) if hash1 satisfies hash2, 0 if not.  For example, with the
-#           following hashes:
-#
-#              %hash1 = {							%hash2 = {
-#                 'class' => 'header'				'class' => '^h'
-#                 'id'    => 'intro'         }
-#              }
-#
-#           the routine will return 1 if 'aContainmentType' equals 0, cause
-#           'hash1' satisfies the conditions of 'hash2'.  The routine will
-#           return 0 if 'aContainmentType' equals 1, cause 'hash1' doesn't
-#           exclude the conditions of 'hash2'.
-# note:     Class function.
-
-sub _doesHashContainHash {
-		# Get arguments
-	my ($aHash1, $aHash2, $aContainmentType) = @_;
-		# Local variables
-	my ($key1, $value1, $key2, $value2, $result);
-		# Bias to success
-	$result = 1;
-		# Loop through hash2
-	HASH2: while (($key2, $value2) = each %$aHash2) {
-		# Yes, values are available;
-			# Get value1
-		$value1 = $aHash1->{$key2};
-			# Does value1 match criteria of value2?
-		if (defined($value1) && $value1 =~ m/$value2/) {
-			# Yes, value1 matches criteria of value2;
-				# Containment type was exclude?
-			if ($aContainmentType == CONTAINMENT_EXCLUDE) {
-				# Yes, containment type was exclude;
-					# Indicate condition fails
-				$result = 0;
-					# Reset 'each' iterator which we're going to break
-				keys %$aHash2;
-					# Break loop
-				last HASH2;
-			}
-		}
-		else {
-			# No, value1 didn't match criteria of value2;
-				# Containment type was include?
-			if ($aContainmentType == CONTAINMENT_INCLUDE) {
-				# Yes, containment type was include;
-					# Indicate condition fails
-				$result = 0;
-					# Reset 'each' iterator which we're going to break
-				keys %$aHash2;
-					# Break loop
-				last HASH2;
-			}
-		}
-	}
-		# Return value
-	return $result;
-}  # _doesHashContainHash()
-
-
-#--- HTML::TocGenerator::_extend() --------------------------------------------
-# function: Extend ToC.
-#           - $aString: String to parse.
-
-sub _extend {
-		# Get arguments
-	my ($self, $aFile) = @_;
-		# Local variables
-	my ($file);
-		# Parse string
-	$self->parse($aFile);
-		# Flush remaining buffered text
-	$self->eof();
-}  # _extend()
-
-
-#--- HTML::TocGenerator::_extendFromFile() ------------------------------------
-# function: Extend ToC.
-#           - $aFile: (reference to array of) file to parse.
-
-sub _extendFromFile {
-		# Get arguments
-	my ($self, $aFile) = @_;
-		# Local variables
-	my ($file, @files);
-		# Dereference array reference or make array of file specification
-	@files = (ref($aFile) =~ m/ARRAY/) ? @$aFile : ($aFile);
-		# Loop through files
-	foreach $file (@files) {
-			# Store filename
-		$self->{_currentFile} = $file;
-			# Parse file
-		$self->parse_file($file);
-			# Flush remaining buffered text
-		$self->eof();
-	}
-}  # _extendFromFile()
-
-
-#--- HTML::TocGenerator::_formatHeadingLevel() --------------------------------
-# function: Format heading level.
-# args:     - $aLevel: Level of current heading
-#           - $aClass: Class of current heading
-#           - $aGroup: Group of current heading
-#           - $aToc: Toc of current heading
-
-sub _formatHeadingLevel {
-		# Get arguments
-	my ($self, $aLevel, $aClass, $aGroup, $aToc) = @_;
-		# Local variables
-	my ($result, $headingNumber, $numberingStyle);
-
-	$headingNumber = $self->_getGroupIdManager($aToc)->
-		{levels}{$aClass}[$aLevel - 1] || 0;
-
-		# Alias numbering style of current group
-	$numberingStyle = $aGroup->{numberingStyle};
-
-	SWITCH: {
-		if ($numberingStyle eq "decimal") {
-			$result = $headingNumber;
-			last SWITCH;
-		}
-		if ($numberingStyle eq "lower-alpha") {
-			$result = chr($headingNumber + ord('a') - 1);
-			last SWITCH;
-		}
-		if ($numberingStyle eq "upper-alpha") {
-			$result = chr($headingNumber + ord('A') - 1);
-			last SWITCH;
-		}
-		if ($numberingStyle eq "lower-roman") {
-			require Roman;
-			$result = Roman::roman($headingNumber);
-			last SWITCH;
-		}
-		if ($numberingStyle eq "upper-roman") {
-			require Roman;
-			$result = Roman::Roman($headingNumber);
-			last SWITCH;
-		}
-		die "Unknown case: $numberingStyle";
-	}
-		# Return value
-	return $result;
-}	# _formatHeadingLevel()
-
-
-#--- HTML::TocGenerator::_formatTocNode() -------------------------------------
-# function: Format heading node.
-# args:     - $aLevel: Level of current heading
-#           - $aClass: Class of current heading
-#           - $aGroup: Group of current heading
-#           - $aToc: Toc of current heading
-
-sub _formatTocNode {
-		# Get arguments
-	my ($self, $aLevel, $aClass, $aGroup, $aToc) = @_;
-		# Local variables
-	my ($result, $level, $levelGroups);
-
-		# Alias 'levelGroups' of right 'groupId'
-	$levelGroups = $aToc->{_levelGroups}{$aGroup->{'groupId'}};
-		# Loop through levels
-	for ($level = 1; $level <= $aLevel; $level++) {
-			# If not first level, add dot
-		$result = ($result ? $result . "." : $result);
-			# Format heading level using argument group
-		$result .= $self->_formatHeadingLevel(
-			$level, $aClass, @{$levelGroups}[$level - 1], $aToc
-		);
-	}
-		# Return value
-	return $result;
-}  # _formatTocNode()
-     	
-     	
-#--- HTML::TocGenerator::_generate() ------------------------------------------
-# function: Generate ToC.
-# args:     - $aString: Reference to string to parse
-
-sub _generate {
-		# Get arguments
-	my ($self, $aString) = @_;
-		# Local variables
-	my ($toc);
-		# Loop through ToCs
-	foreach $toc (@{$self->{_tocs}}) {
-			# Clear ToC
-		$toc->clear();
-	}
-		# Extend ToCs
-	$self->_extend($aString);
-}  # _generate()
-
-
-#--- HTML::TocGenerator::_generateFromFile() ----------------------------------
-# function: Generate ToC.
-# args:     - $aFile: (reference to array of) file to parse.
-
-sub _generateFromFile {
-		# Get arguments
-	my ($self, $aFile) = @_;
-		# Local variables
-	my ($toc);
-		# Loop through ToCs
-	foreach $toc (@{$self->{_tocs}}) {
-			# Clear ToC
-		$toc->clear();
-	}
-		# Extend ToCs
-	$self->_extendFromFile($aFile);
-}  # _generateFromFile()
-
-
-#--- HTML::TocGenerator::_getGroupIdManager() ---------------------------------
-# function: Get group id manager.
-# args:     - $aToc: Active ToC.
-# returns:  Group id levels.
-
-sub _getGroupIdManager {
-		# Get arguments
-	my ($self, $aToc) = @_;
-		# Local variables
-	my ($result);
-		# Global groups?
-	if ($self->{options}{'doUseGroupsGlobal'}) {
-		# Yes, global groups;
-		$result = $self;
-	}
-	else {
-		# No, local groups;
-		$result = $aToc;
-	}
-		# Return value
-	return $result;
-}  # _getGroupIdManager()
-
-
-#--- HTML::TocGenerator::_initializeBatch() -----------------------------------
-# function: Initialize batch.  This function is called once when a parse batch
-#           is started.
-# args:     - $aTocs: Reference to array of tocs.
-
-sub _initializeBatch {
-		# Get arguments
-	my ($self, $aTocs) = @_;
-		# Local variables
-	my ($toc);
-
-		# Store reference to tocs
-		
-		# Is ToC specification reference to array?
-	if (ref($aTocs) =~ m/ARRAY/) {
-		# Yes, ToC specification is reference to array;
-			# Store array reference
-		$self->{_tocs} = $aTocs;
-	}
-	else {
-		# No, ToC specification is reference to ToC object;
-			# Wrap reference in array reference, containing only one element
-		$self->{_tocs} = [$aTocs];
-	}
-		# Loop through ToCs
-	foreach $toc (@{$self->{_tocs}}) {
-			# Parse ToC options
-		$toc->parseOptions();
-	}
-}  # _initializeBatch()
-
-
-#--- HTML::TocGenerator::_initializeExtenderBatch() --------------------------
-# function: Initialize 'extender' batch.  This function is called once when a 
-#           parse batch is started.
-# args:     - $aTocs: Reference to array of tocs.
-
-sub _initializeExtenderBatch {
-		# Get arguments
-	my ($self, $aTocs) = @_;
-		# Do general batch initialization
-	$self->_initializeBatch($aTocs);
-		# Parse ToC options
-	$self->_parseTocOptions();
-		# Indicate start of batch
-	$self->{_doGenerateToc} = 1;
-}  # _initializeExtenderBatch()
-
-
-#--- HTML::TocGenerator::_initializeGeneratorBatch() --------------------------
-# function: Initialize generator batch.  This function is called once when a 
-#           parse batch is started.
-# args:     - $aTocs: Reference to array of tocs.
-#           - $aOptions: optional options
-
-sub _initializeGeneratorBatch {
-		# Get arguments
-	my ($self, $aTocs, $aOptions) = @_;
-		# Add invocation options
-	$self->setOptions($aOptions);
-		# Option 'doUseGroupsGlobal' specified?
-	if (!defined($self->{options}{'doUseGroupsGlobal'})) {
-		# No, options 'doUseGroupsGlobal' not specified;
-			# Default to no 'doUseGroupsGlobal'
-		$self->{options}{'doUseGroupsGlobal'} = 0;
-	}
-		# Global groups?
-	if ($self->{options}{'doUseGroupsGlobal'}) {
-		# Yes, global groups;
-			# Reset groups and levels
-		$self->_resetStackVariables();
-	}
-		# Do 'extender' batch initialization
-	$self->_initializeExtenderBatch($aTocs);
-}  # _initializeGeneratorBatch()
-
-
-#--- HTML::TocGenerator::_linkTocToToken() ------------------------------------
-# function: Link ToC to token.
-# args:     - $aToc: ToC to add token to.
-#           - $aFile
-#           - $aGroupId
-#           - $aLevel
-#           - $aNode
-#           - $aGroupLevel
-#           - $aLinkType
-#           - $aTokenAttributes: reference to hash containing attributes of 
-#                currently parsed token
-
-sub _linkTocToToken {
-		# Get arguments
-	my (
-		$self, $aToc, $aFile, $aGroupId, $aLevel, $aNode, $aGroupLevel, 
-		$aDoLinkToId, $aTokenAttributes
-	) = @_;
-		# Local variables
-	my ($file, $groupId, $level, $node, $anchorName);
-	my ($doInsertAnchor, $doInsertId);
-
-		# Fill local arguments to be used by templates
-	$file    = $aFile;
-	$groupId = $aGroupId;
-	$level   = $aLevel;
-	$node    = $aNode;
-	
-		# Assemble anchor name
-	$anchorName = 
-		ref($aToc->{_templateAnchorName}) eq "CODE" ?
-			&{$aToc->{_templateAnchorName}}(
-				$aFile, $aGroupId, $aLevel, $aNode
-			) : 
-			eval($aToc->{_templateAnchorName});
-
-		# Bias to insert anchor name
-	$doInsertAnchor = 1;
-	$doInsertId     = 0;
-		# Link to 'id'?
-	if ($aDoLinkToId) {
-		# Yes, link to 'id';
-			# Indicate to insert anchor id
-		$doInsertAnchor = 0;
-		$doInsertId     = 1;
-			# Id attribute is available?
-		if (defined($aTokenAttributes->{id})) {
-			# Yes, id attribute is available;
-				# Use existing ids?
-			if ($aToc->{options}{'doUseExistingIds'}) {
-				# Yes, use existing ids;
-					# Use existing id
-				$anchorName = $aTokenAttributes->{id};
-					# Indicate to not insert id
-				$doInsertId = 0;
-			}
-		}
-
-	}
-	else {
-		# No, link to 'name';
-			# Anchor name is currently active?
-		if (defined($self->{_activeAnchorName})) {
-			# Yes, anchor name is currently active;
-				# Use existing anchors?
-			if ($aToc->{options}{'doUseExistingAnchors'}) {
-				# Yes, use existing anchors;
-					# Use existing anchor name
-				$anchorName = $self->{_activeAnchorName};
-					# Indicate to not insert anchor name
-				$doInsertAnchor = 0;
-			}
-			else {
-				# No, don't use existing anchors; insert new anchor;
-					# 
-			}
-		}
-	}
-
-		# Add reference to ToC
-	$aToc->{_toc} .= 
-		ref($aToc->{_templateAnchorHrefBegin}) eq "CODE" ?
-			&{$aToc->{_templateAnchorHrefBegin}}(
-				$aFile, $aGroupId, $aLevel, $aNode, $anchorName
-			) : 
-			eval($aToc->{_templateAnchorHrefBegin});
-
-		# Bias to not output anchor name end
-	$self->{_doOutputAnchorNameEnd} = 0;
-		# Must anchor be inserted?
-	if ($doInsertAnchor) {
-		# Yes, anchor must be inserted;
-			# Allow adding of anchor name begin token to text by calling 
-			# 'anchorNameBegin' method
-		$self->anchorNameBegin(
-			ref($aToc->{_templateAnchorNameBegin}) eq "CODE" ?
-				&{$aToc->{_templateAnchorNameBegin}}(
-					$aFile, $aGroupId, $aLevel, $aNode, $anchorName
-				) :
-				eval($aToc->{_templateAnchorNameBegin}),
-			$aToc
-		);
-	}
-
-		# Must anchorId attribute be inserted?
-	if ($doInsertId) {
-		# Yes, anchorId attribute must be inserted;
-			# Allow adding of anchorId attribute to text by calling 'anchorId'
-			# method
-		$self->anchorId($anchorName);
-	}
-}  # _linkTocToToken()
-
-
-#--- HTML::TocGenerator::_outputAnchorNameEndConditionally() ------------------
-# function: Output 'anchor name end' if necessary
-# args:     - $aToc: ToC of which 'anchor name end' must be output.
-
-sub _outputAnchorNameEndConditionally {
-		# Get arguments
-	my ($self, $aToc) = @_;
-		# Must anchor name end be output?
-	if ($self->{_doOutputAnchorNameEnd}) {
-		# Yes, output anchor name end;
-			# Allow adding of anchor to text by calling 'anchorNameEnd' 
-			# method
-		$self->anchorNameEnd(
-			ref($aToc->{_templateAnchorNameEnd}) eq "CODE" ?
-				&{$aToc->{_templateAnchorNameEnd}} :
-				eval($aToc->{_templateAnchorNameEnd}),
-			$aToc
-		);
-	}
-}  # _outputAnchorNameEndConditionally()
-
-
-#--- HTML::TocGenerator::_parseTocOptions() -----------------------------------
-# function: Parse ToC options.
-
-sub _parseTocOptions {
-		# Get arguments
-	my ($self) = @_;
-		# Local variables
-	my ($toc, $group, $tokens, $tokenType, $i);
-		# Create parsers for ToC tokens
-	$self->{_tokensTocBegin} = [];
-	my $tokenTocBeginParser = HTML::_TokenTocBeginParser->new(
-		$self->{_tokensTocBegin}
-	);
-	my $tokenTocEndParser = HTML::_TokenTocEndParser->new();
-		# Loop through ToCs
-	foreach $toc (@{$self->{_tocs}}) {
-			# Reference parser ToC to current ToC
-		$tokenTocBeginParser->setToc($toc);
-			# Loop through 'tokenToToc' groups
-		foreach $group (@{$toc->{options}{'tokenToToc'}}) {
-				# Reference parser group to current group
-			$tokenTocBeginParser->setGroup($group);
-				# Parse 'tokenToToc' group
-			$tokenTocBeginParser->parse($group->{'tokenBegin'});
-				# Flush remaining buffered text
-			$tokenTocBeginParser->eof();
-			$tokenTocEndParser->parse(
-				$group->{'tokenEnd'}, 
-				$tokenTocBeginParser->{_lastAddedToken},
-				$tokenTocBeginParser->{_lastAddedTokenType}
-			);
-				# Flush remaining buffered text
-			$tokenTocEndParser->eof();
-		}
-	}
-}  # _parseTocOptions()
-
-
-#--- HTML::TocGenerator::_processTocEndingToken() -----------------------------
-# function: Process ToC-ending-token.
-# args:     - $aTocToken: token which acts as ToC-ending-token.
-
-sub _processTocEndingToken {
-		# Get arguments
-	my ($self, $aTocToken) = @_;
-		# Local variables
-	my ($toc);
-		# Aliases
-	$toc = $aTocToken->[TT_TOC];
-		# Link ToC to tokens?
-	if ($toc->{options}{'doLinkToToken'}) {
-		# Yes, link ToC to tokens;
-			# Add anchor href end
-		$toc->{_toc} .= 
-			(ref($toc->{_templateAnchorHrefEnd}) eq "CODE") ?
-				&{$toc->{_templateAnchorHrefEnd}} : 
-				eval($toc->{_templateAnchorHrefEnd});
-
-			# Output anchor name end only if necessary
-		$self->_outputAnchorNameEndConditionally($toc);
-	}
-}  # _processTocEndingToken()
-
-
-#--- HTML::TocGenerator::_processTocStartingToken() ---------------------------
-# function: Process ToC-starting-token.
-# args:     - $aTocToken: token which acts as ToC-starting-token.
-#           - $aTokenType: type of token.  Can be either TT_TOKENTYPE_START,
-#                _END, _TEXT, _COMMENT or _DECLARATION.
-#           - $aTokenAttributes: reference to hash containing attributes of 
-#                currently parsed token
-#           - $aTokenOrigText: reference to original token text
-
-sub _processTocStartingToken {
-		# Get arguments
-	my ($self, $aTocToken, $aTokenType, $aTokenAttributes, $aTokenOrigText) = @_;
-		# Local variables
-	my ($i, $level, $doLinkToId, $node, $groupLevel);
-	my ($file, $tocTokenId, $groupId, $toc, $attribute);
-		# Aliases
-	$file        = $self->{_currentFile};
-	$toc		    = $aTocToken->[TT_TOC];
-	$level	    = $aTocToken->[TT_GROUP]{'level'};
-	$groupId	    = $aTocToken->[TT_GROUP]{'groupId'};
-
-		# Retrieve 'doLinkToId' setting from either group options or toc options
-	$doLinkToId = (defined($aTocToken->[TT_GROUP]{'doLinkToId'})) ?
-		$aTocToken->[TT_GROUP]{'doLinkToId'} : $toc->{options}{'doLinkToId'}; 
-	
-		# Link to 'id' and tokenType isn't 'start'?
-	if (($doLinkToId) && ($aTokenType != TT_TOKENTYPE_START)) {
-		# Yes, link to 'id' and tokenType isn't 'start';
-			# Indicate to *not* link to 'id'
-		$doLinkToId = 0;
-	}
-
-	if (ref($level) eq "CODE") {
-		$level = &$level($self->{_currentFile}, $node);
-	}
-	if (ref($groupId) eq "CODE") {
-		$groupId = &$groupId($self->{_currentFile}, $node);
-	}
-
-		# Determine class level
-
-	my $groupIdManager = $self->_getGroupIdManager($toc);
-		# Known group?
-	if (!exists($groupIdManager->{groupIdLevels}{$groupId})) {
-		# No, unknown group;
-			# Add group
-		$groupIdManager->{groupIdLevels}{$groupId} = keys(
-			%{$groupIdManager->{groupIdLevels}}
-		) + 1;
-	}
-	$groupLevel = $groupIdManager->{groupIdLevels}{$groupId};
-
-		# Temporarily allow symbolic references
-	#no strict qw(refs);
-		# Increase level
-	$groupIdManager->{levels}{$groupId}[$level - 1] += 1;
-		# Reset remaining levels of same group
-	for ($i = $level; $i < @{$groupIdManager->{levels}{$groupId}}; $i++) {
-		$groupIdManager->{levels}{$groupId}[$i] = 0;
-	}
-
-		# Assemble numeric string indicating current level
-	$node = $self->_formatTocNode(
-		$level, $groupId, $aTocToken->[TT_GROUP], $toc
-	);
-
-		# Add newline if _toc not empty
-	if ($toc->{_toc}) { 
-		$toc->{_toc} .= "\n";
-	}
-
-		# Add toc item info
-	$toc->{_toc} .= "$level $groupLevel $groupId $node " .
-		$groupIdManager->{levels}{$groupId}[$level - 1] . " ";
-
-		# Add value of 'id' attribute if available
-	if (defined($aTokenAttributes->{id})) {
-		$toc->{_toc} .= $aTokenAttributes->{id};
-	}
-	$toc->{_toc} .= " ";
-		# Link ToC to tokens?
-	if ($toc->{options}{'doLinkToToken'}) {
-		# Yes, link ToC to tokens;
-			# Link ToC to token
-		$self->_linkTocToToken(
-			$toc, $file, $groupId, $level, $node, $groupLevel, $doLinkToId,
-			$aTokenAttributes
-		);
-	}
-
-		# Number tokens?
-	if (
-		$aTocToken->[TT_GROUP]{'doNumberToken'} || 
-		(
-			! defined($aTocToken->[TT_GROUP]{'doNumberToken'}) && 
-			$toc->{options}{'doNumberToken'}
-		)
-	) {
-		# Yes, number tokens;
-			# Add number by calling 'number' method
-		$self->number(
-			ref($toc->{_templateTokenNumber}) eq "CODE" ?
-				&{$toc->{_templateTokenNumber}}(
-					$node, $groupId, $file, $groupLevel, $level, $toc
-				) : 
-				eval($toc->{_templateTokenNumber}),
-			$toc
-		);
-	}
-
-		# Must attribute be used as ToC text?
-	if (defined($aTocToken->[TT_ATTRIBUTES_TOC])) {
-		# Yes, attribute must be used as ToC text;
-			# Loop through attributes
-		foreach $attribute (@{$aTocToken->[TT_ATTRIBUTES_TOC]}) {
-				# Attribute is available?
-			if (defined($$aTokenAttributes{$attribute})) {
-				# Yes, attribute is available;
-					# Add attribute value to ToC
-				$self->_processTocText($$aTokenAttributes{$attribute}, $toc);
-			}
-			else {
-				# No, attribute isn't available;
-					# Show warning
-				$self->_showWarning(
-					WARNING_TOC_ATTRIBUTE_PS_NOT_AVAILABLE_WITHIN_PS,
-					[$attribute, $$aTokenOrigText]
-				);
-			}
-				# Output anchor name end only if necessary
-			#$self->_outputAnchorNameEndConditionally($toc);
-				# End attribute
-			$self->_processTocEndingToken($aTocToken);
-		}
-	}
-	else {
-		# No, attribute mustn't be used as ToC text;
-			# Add end token to 'end token array'
-		push(
-			@{$self->{_tokensTocEnd}[$aTocToken->[TT_TAG_TYPE_END]]}, $aTocToken
-		);
-	}
-}  # _processTocStartingToken()
-
-
-#--- HTML::TocGenerator::_processTocText() ------------------------------------
-# function: This function processes text which must be added to the preliminary
-#           ToC.
-# args:     - $aText: Text to add to ToC.
-#           - $aToc: ToC to add text to.
-
-sub _processTocText {
-		# Get arguments
-	my ($self, $aText, $aToc) = @_;
-		# Add text to ToC
-	$aToc->{_toc} .= $aText;
-}  # _processTocText()
-
-
-#--- HTML::TocGenerator::_processTokenAsTocEndingToken() ----------------------
-# function: Check for token being a token to use for triggering the end of
-#           a ToC line and process it accordingly.
-# args:     - $aTokenType: type of token: 'start', 'end', 'comment' or 'text'.
-#           - $aTokenId: token id of currently parsed token
-
-sub _processTokenAsTocEndingToken {
-		# Get arguments
-	my ($self, $aTokenType, $aTokenId) = @_;
-		# Local variables
-	my ($i, $tokenId, $toc, $tokens);
-		# Loop through dirty start tokens
-	$i = 0;
-
-		# Alias token array of right type
-	$tokens = $self->{_tokensTocEnd}[$aTokenType];
-		# Loop through token array
-	while ($i < scalar @$tokens) {
-			# Aliases
-		$tokenId = $tokens->[$i][TT_TAG_END];
-			# Does current end tag equals dirty tag?
-		if ($aTokenId eq $tokenId) {
-			# Yes, current end tag equals dirty tag;
-				# Process ToC-ending-token
-			$self->_processTocEndingToken($tokens->[$i]);
-				# Remove dirty tag from array, automatically advancing to
-				# next token
-			splice(@$tokens, $i, 1);
-		}
-		else {
-			# No, current end tag doesn't equal dirty tag;
-				# Advance to next token
-			$i++;
-		}
-	}
-}  # _processTokenAsTocEndingToken()
-
-
-#--- HTML::TocGenerator::_processTokenAsTocStartingToken() --------------------
-# function: Check for token being a ToC-starting-token and process it 
-#           accordingly.
-# args:     - $aTokenType: type of token.  Can be either TT_TOKENTYPE_START,
-#                _END, _TEXT, _COMMENT or _DECLARATION.
-#           - $aTokenId: token id of currently parsed token
-#           - $aTokenAttributes: reference to hash containing attributes of 
-#                currently parsed token
-#           - $aTokenOrigText: reference to original text of token
-# returns:  1 if successful, i.e. token is processed as ToC-starting-token, 0
-#           if not.
-
-sub _processTokenAsTocStartingToken {
-		# Get arguments
-	my ($self, $aTokenType, $aTokenId, $aTokenAttributes, $aTokenOrigText) = @_;
-		# Local variables
-	my ($level, $levelToToc, $groupId, $groupToToc);
-	my ($result, $tocToken, $tagBegin, @tokensTocBegin, $fileSpec);
-		# Bias to token not functioning as ToC-starting-token
-	$result = 0;
-		# Loop through start tokens of right type
-	foreach $tocToken (@{$self->{_tokensTocBegin}[$aTokenType]}) {
-			# Alias file filter
-		$fileSpec = $tocToken->[TT_GROUP]{'fileSpec'};
-			# File matches?
-		if (!defined($fileSpec) || (
-			defined($fileSpec) &&
-			($self->{_currentFile} =~ m/$fileSpec/)
-		)) {
-			# Yes, file matches;
-				# Alias tag begin
-			$tagBegin = $tocToken->[TT_TAG_BEGIN];
-				# Tag and attributes match?
-			if (
-				defined($tagBegin) && 
-				($aTokenId =~ m/$tagBegin/) && 
-				HTML::TocGenerator::_doesHashContainHash(
-					$aTokenAttributes, $tocToken->[TT_INCLUDE_ATTRIBUTES_BEGIN], 0
-				) &&
-				HTML::TocGenerator::_doesHashContainHash(
-					$aTokenAttributes, $tocToken->[TT_EXCLUDE_ATTRIBUTES_BEGIN], 1
-				)
-			) {
-				# Yes, tag and attributes match;
-					# Aliases
-				$level	    = $tocToken->[TT_GROUP]{'level'};
-				$levelToToc = $tocToken->[TT_TOC]{options}{'levelToToc'};
-				$groupId     = $tocToken->[TT_GROUP]{'groupId'}; 
-				$groupToToc = $tocToken->[TT_TOC]{options}{'groupToToc'};
-					# Must level and group be processed?
-				if (
-					($level =~ m/$levelToToc/) &&
-					($groupId =~ m/$groupToToc/)
-				) {
-					# Yes, level and group must be processed;
-						# Indicate token acts as ToC-starting-token
-					$result = 1;
-						# Process ToC-starting-token
-					$self->_processTocStartingToken(
-						$tocToken, $aTokenType, $aTokenAttributes, $aTokenOrigText
-					);
-				}
-			}
-		}
-	}
-		# Return value
-	return $result;
-}  # _processTokenAsTocStartingToken()
-
-
-#--- HTML::TocGenerator::_resetBatchVariables() -------------------------------
-# function: Reset variables which are set because of batch invocation.
-
-sub _resetBatchVariables {
-		# Get arguments
-	my ($self) = @_;
-
-		# Filename of current file being parsed, empty string if not available
-	$self->{_currentFile} = "";
-		# Arrays containing start, end, comment, text & declaration tokens which 
-		# must trigger the ToC assembling.  Each array element may contain a 
-		# reference to an array containing the following elements:
-		#
-      #    TT_TAG_BEGIN                => 0;
-      #    TT_TAG_END                  => 1;
-      #    TT_TAG_TYPE_END             => 2;
-      #    TT_INCLUDE_ATTRIBUTES_BEGIN => 3;
-      #    TT_EXCLUDE_ATTRIBUTES_BEGIN => 4;
-      #    TT_INCLUDE_ATTRIBUTES_END   => 5;
-      #    TT_EXCLUDE_ATTRIBUTES_END   => 6;
-      #    TT_GROUP                    => 7;
-      #    TT_TOC                      => 8;
-		#    TT_ATTRIBUTES_TOC           => 9;
-		#
-	$self->{_tokensTocBegin} = [
-		[],  # TT_TOKENTYPE_START      
-		[],  # TT_TOKENTYPE_END        
-		[],  # TT_TOKENTYPE_COMMENT    
-		[],  # TT_TOKENTYPE_TEXT       
-		[]   # TT_TOKENTYPE_DECLARATION
-	];
-	$self->{_tokensTocEnd} = [
-		[],  # TT_TOKENTYPE_START      
-		[],  # TT_TOKENTYPE_END        
-		[],  # TT_TOKENTYPE_COMMENT    
-		[],  # TT_TOKENTYPE_TEXT       
-		[]   # TT_TOKENTYPE_DECLARATION
-	];
-		# TRUE if ToCs have been initialized, FALSE if not.
-	$self->{_doneInitializeTocs} = 0;
-		# Array of ToCs to process
-	$self->{_tocs} = [];
-		# Active anchor name
-	$self->{_activeAnchorName} = undef;
-}  # _resetBatchVariables()
-
-
-#--- HTML::TocGenerator::_resetStackVariables() -------------------------------
-# function: Reset variables which cumulate during ToC generation.
-
-sub _resetStackVariables {
-		# Get arguments
-	my ($self) = @_;
-		# Reset variables
-	$self->{levels}        = undef;
-	$self->{groupIdLevels} = undef;
-}  # _resetStackVariables()
-
-
-#--- HTML::TocGenerator::_setActiveAnchorName() -------------------------------
-# function: Set active anchor name.
-# args:     - aAnchorName: Name of anchor name to set active.
-
-sub _setActiveAnchorName {
-		# Get arguments
-	my ($self, $aAnchorName) = @_;
-		# Set active anchor name
-	$self->{_activeAnchorName} = $aAnchorName;
-}  # _setActiveAnchorName()
-
-
-#--- HTML::TocGenerator::_showWarning() ---------------------------------------
-# function: Show warning.
-# args:     - aWarningNr: Number of warning to show.
-#           - aWarningArgs: Arguments to display within the warning.
-
-sub _showWarning {
-		# Get arguments
-	my ($self, $aWarningNr, $aWarningArgs) = @_;
-		# Local variables
-	my (%warnings);
-		# Set warnings
-	%warnings = (
-		WARNING_NESTED_ANCHOR_PS_WITHIN_PS()               => 
-			"Nested anchor '%s' within anchor '%s'.", 
-		WARNING_TOC_ATTRIBUTE_PS_NOT_AVAILABLE_WITHIN_PS() =>
-			"ToC attribute '%s' not available within token '%s'.",
-	);
-		# Show warning
-	print STDERR "warning ($aWarningNr): " . sprintf($warnings{"$aWarningNr"}, @$aWarningArgs) . "\n";
-}  # _showWarning()
-
-
-#--- HTML::TocGenerator::anchorId() -------------------------------------------
-# function: Anchor id processing method.  Leave it up to the descendant to do 
-#           something useful with it.
-# args:     - $aAnchorId
-#           - $aToc: Reference to ToC to which anchorId belongs.
-
-sub anchorId {
-}  # anchorId()
-
-
-#--- HTML::TocGenerator::anchorNameBegin() ------------------------------------
-# function: Anchor name begin processing method.  Leave it up to the descendant
-#           to do something useful with it.
-# args:     - $aAnchorName
-#           - $aToc: Reference to ToC to which anchorname belongs.
-
-sub anchorNameBegin {
-}  # anchorNameBegin()
-
-
-#--- HTML::TocGenerator::anchorNameEnd() --------------------------------------
-# function: Anchor name end processing method.  Leave it up to the descendant
-#           to do something useful with it.
-# args:     - $aAnchorName
-#           - $aToc: Reference to ToC to which anchorname belongs.
-
-sub anchorNameEnd {
-}  # anchorNameEnd()
-
-
-#--- HTML::TocGenerator::comment() --------------------------------------------
-# function: Process comment.
-# args:     - $aComment: comment text with '<!--' and '-->' tags stripped off.
-
-sub comment {
-		# Get arguments
-	my ($self, $aComment) = @_;
-		# Must a ToC be generated?
-	if ($self->{_doGenerateToc}) {
-		# Yes, a ToC must be generated
-			# Process end tag as ToC-starting-token
-		$self->_processTokenAsTocStartingToken(
-			TT_TOKENTYPE_COMMENT, $aComment, undef, \$aComment
-		);
-			# Process end tag as token which ends ToC registration
-		$self->_processTokenAsTocEndingToken(
-			TT_TOKENTYPE_COMMENT, $aComment
-		);
-	}
-}  # comment()
-
-
-#--- HTML::TocGenerator::end() ------------------------------------------------
-# function: This function is called every time a closing tag is encountered.
-# args:     - $aTag: tag name (in lower case).
-#           - $aOrigText: tag name including brackets.
-
-sub end {
-		# Get arguments
-	my ($self, $aTag, $aOrigText) = @_;
-		# Local variables
-	my ($tag, $toc, $i);
-		# Must a ToC be generated?
-	if ($self->{_doGenerateToc}) {
-		# Yes, a ToC must be generated
-			# Process end tag as ToC-starting-token
-		$self->_processTokenAsTocStartingToken(
-			TT_TOKENTYPE_END, $aTag, undef, \$aOrigText
-		);
-			# Process end tag as ToC-ending-token
-		$self->_processTokenAsTocEndingToken(
-			TT_TOKENTYPE_END, $aTag
-		);
-			# Tag is of type 'anchor'?
-		if (defined($self->{_activeAnchorName}) && ($aTag eq "a")) {
-			# Yes, tag is of type 'anchor';
-				# Reset dirty anchor
-			$self->{_activeAnchorName} = undef;
-		}
-	}
-}  # end()
-
-
-#--- HTML::TocGenerator::extend() ---------------------------------------------
-# function: Extend ToCs.
-# args:     - $aTocs: Reference to array of ToC objects
-#           - $aString: String to parse.
-
-sub extend {
-		# Get arguments
-	my ($self, $aTocs, $aString) = @_;
-		# Initialize TocGenerator batch
-	$self->_initializeExtenderBatch($aTocs);
-		# Extend ToCs
-	$self->_extend($aString);
-		# Deinitialize TocGenerator batch
-	$self->_deinitializeExtenderBatch();
-}  # extend()
-
-
-#--- HTML::TocGenerator::extendFromFile() -------------------------------------
-# function: Extend ToCs.
-# args:     - @aTocs: Reference to array of ToC objects
-#           - @aFiles: Reference to array of files to parse.
-
-sub extendFromFile {
-		# Get arguments
-	my ($self, $aTocs, $aFiles) = @_;
-		# Initialize TocGenerator batch
-	$self->_initializeExtenderBatch($aTocs);
-		# Extend ToCs
-	$self->_extendFromFile($aFiles);
-		# Deinitialize TocGenerator batch
-	$self->_deinitializeExtenderBatch();
-}  # extendFromFile()
-
-
-#--- HTML::TocGenerator::generate() -------------------------------------------
-# function: Generate ToC.
-# args:     - $aToc: Reference to (array of) ToC object(s)
-#           - $aString: Reference to string to parse
-#           - $aOptions: optional options
-
-sub generate {
-		# Get arguments
-	my ($self, $aToc, $aString, $aOptions) = @_;
-		# Initialize TocGenerator batch
-	$self->_initializeGeneratorBatch($aToc, $aOptions);
-		# Do generate ToC
-	$self->_generate($aString);
-		# Deinitialize TocGenerator batch
-	$self->_deinitializeGeneratorBatch();
-}  # generate()
-
-
-#--- HTML::TocGenerator::generateFromFile() -----------------------------------
-# function: Generate ToC.
-# args:     - $aToc: Reference to (array of) ToC object(s)
-#           - $aFile: (reference to array of) file to parse.
-#           - $aOptions: optional options
-
-sub generateFromFile {
-		# Get arguments
-	my ($self, $aToc, $aFile, $aOptions) = @_;
-		# Initialize TocGenerator batch
-	$self->_initializeGeneratorBatch($aToc, $aOptions);
-		# Do generate ToC
-	$self->_generateFromFile($aFile);
-		# Deinitialize TocGenerator batch
-	$self->_deinitializeGeneratorBatch();
-}  # generateFromFile()
-
-
-#--- HTML::TocGenerator::number() ---------------------------------------------
-# function: Heading number processing method.  Leave it up to the descendant
-#           to do something useful with it.
-# args:     - $aNumber
-#           - $aToc: Reference to ToC to which anchorname belongs.
-
-sub number {
-		# Get arguments
-	my ($self, $aNumber, $aToc) = @_;
-}  # number()
-
-
-#--- HTML::TocGenerator::parse() ----------------------------------------------
-# function: Parse scalar.
-# args:     - $aString: string to parse
-
-sub parse {
-		# Get arguments
-	my ($self, $aString) = @_;
-		# Call ancestor
-	$self->SUPER::parse($aString);
-}  # parse()
-
-
-#--- HTML::TocGenerator::parse_file() -----------------------------------------
-# function: Parse file.
-
-sub parse_file {
-		# Get arguments
-	my ($self, $aFile) = @_;
-		# Call ancestor
-	$self->SUPER::parse_file($aFile);
-}  # parse_file()
-
-
-#--- HTML::TocGenerator::setOptions() -----------------------------------------
-# function: Set options.
-# args:     - aOptions: Reference to hash containing options.
-
-sub setOptions {
-		# Get arguments
-	my ($self, $aOptions) = @_;
-		# Options are defined?
-	if (defined($aOptions)) {
-		# Yes, options are defined; add to options
-		%{$self->{options}} = (%{$self->{options}}, %$aOptions);
-	}
-}  # setOptions()
-
-
-#--- HTML::TocGenerator::start() ----------------------------------------------
-# function: This function is called every time an opening tag is encountered.
-# args:     - $aTag: tag name (in lower case).
-#           - $aAttr: reference to hash containing all tag attributes (in lower
-#                case).
-#           - $aAttrSeq: reference to array containing all tag attributes (in 
-#                lower case) in the original order
-#           - $aOrigText: the original HTML text
-
-sub start {
-		# Get arguments
-	my ($self, $aTag, $aAttr, $aAttrSeq, $aOrigText) = @_;
-	$self->{isTocToken} = 0;
-		# Start tag is of type 'anchor name'?
-	if ($aTag eq "a" && defined($aAttr->{name})) {
-		# Yes, start tag is of type 'anchor name';
-			# Is another anchor already active?
-		if (defined($self->{_activeAnchorName})) {
-			# Yes, another anchor is already active;
-				# Is the first anchor inserted by 'TocGenerator'?
-			if ($self->{_doOutputAnchorNameEnd}) {
-				# Yes, the first anchor is inserted by 'TocGenerator';
-					# Show warning
-				$self->_showWarning(
-					WARNING_NESTED_ANCHOR_PS_WITHIN_PS,
-					[$aOrigText, $self->{_activeAnchorName}]
-				);
-			}
-		}
-			# Set active anchor name
-		$self->_setActiveAnchorName($aAttr->{name});
-	}
-		# Must a ToC be generated?
-	if ($self->{_doGenerateToc}) {
-		# Yes, a ToC must be generated
-			# Process start tag as ToC token
-		$self->{isTocToken} = $self->_processTokenAsTocStartingToken(
-			TT_TOKENTYPE_START, $aTag, $aAttr, \$aOrigText
-		);
-			# Process end tag as ToC-ending-token
-		$self->_processTokenAsTocEndingToken(
-			TT_TOKENTYPE_START, $aTag
-		);
-	}
-}  # start()
-
-
-#--- HTML::TocGenerator::text() -----------------------------------------------
-# function: This function is called every time plain text is encountered.
-# args:     - @_: array containing data.
-
-sub text {
-		# Get arguments
-	my ($self, $aText) = @_;
-		# Local variables
-	my ($text, $toc, $i, $token, $tokens);
-		# Must a ToC be generated?
-	if ($self->{_doGenerateToc}) {
-		# Yes, a ToC must be generated
-			# Are there dirty start tags?
-
-			# Loop through token types
-		foreach $tokens (@{$self->{_tokensTocEnd}}) {
-				# Loop though tokens
-			foreach $token (@$tokens) {
-					# Add text to toc
-
-					# Alias
-				$toc = $token->[TT_TOC];
-					# Remove possible newlines from text
-				($text = $aText) =~ s/\s*\n\s*/ /g;
-					# Add text to toc
-				$self->_processTocText($text, $toc);
-			}
-		}
-	}
-}  # text()
-
-
-
-
-#=== HTML::_TokenTocParser ====================================================
-# function: Parse 'toc tokens'.  'Toc tokens' mark HTML code which is to be
-#           inserted into the ToC.
-# note:     Used internally.
-
-package HTML::_TokenTocParser;
-
-
-BEGIN {
-	use vars qw(@ISA);
-
-	@ISA = qw(HTML::Parser);
-}
-
-
-END {}
-
-
-#--- HTML::_TokenTocParser::new() ---------------------------------------------
-# function: Constructor
-
-sub new {
-		# Get arguments
-	my ($aType) = @_;
-		# Create instance
-	my $self = $aType->SUPER::new;
-
-		# Return instance
-	return $self;
-}  # new()
-
-
-#--- HTML::_TokenTocParser::_parseAttributes() --------------------------------
-# function: Parse attributes.
-# args:     - $aAttr: Reference to hash containing all tag attributes (in lower
-#                case).
-#           - $aIncludeAttributes: Reference to hash to which 'include
-#                attributes' must be added.
-#           - $aExcludeAttributes: Reference to hash to which 'exclude
-#                attributes' must be added.
-#           - $aTocAttributes: Reference to hash to which 'ToC attributes' 
-#                must be added.
-
-sub _parseAttributes {
-		# Get arguments
-	my (
-		$self, $aAttr, $aIncludeAttributes, $aExcludeAttributes,
-		$aTocAttributes
-	) = @_;
-		# Local variables
-	my ($key, $value);
-	my ($attributeToExcludeToken, $attributeToTocToken);
-		# Get token which marks attributes which must be excluded
-	$attributeToExcludeToken = $self->{_toc}{options}{'attributeToExcludeToken'};
-	$attributeToTocToken     = $self->{_toc}{options}{'attributeToTocToken'};
-		# Loop through attributes
-	while (($key, $value) = each %$aAttr) {
-			# Attribute value equals 'ToC token'?
-		if ($value =~ m/$attributeToTocToken/) {
-			# Yes, attribute value equals 'ToC token';
-				# Add attribute to 'ToC attributes'
-			push @$aTocAttributes, $key;
-		}
-		else {
-			# No, attribute isn't 'ToC' token;
-				# Attribute value starts with 'exclude token'?
-			if ($value =~ m/^$attributeToExcludeToken(.*)/) {
-				# Yes, attribute value starts with 'exclude token';
-					# Add attribute to 'exclude attributes'
-				$$aExcludeAttributes{$key} = "$1";
-			}
-			else {
-				# No, attribute key doesn't start with '-';
-					# Add attribute to 'include attributes'
-				$$aIncludeAttributes{$key} = $value;
-			}
-		}
-	}
-}  # _parseAttributes()
-
-
-
-
-#=== HTML::_TokenTocBeginParser ===============================================
-# function: Parse 'toc tokens'.  'Toc tokens' mark HTML code which is to be
-#           inserted into the ToC.
-# note:     Used internally.
-
-package HTML::_TokenTocBeginParser;
-
-
-BEGIN {
-	use vars qw(@ISA);
-
-	@ISA = qw(HTML::_TokenTocParser);
-}
-
-END {}
-
-
-#--- HTML::_TokenTocBeginParser::new() ----------------------------------------
-# function: Constructor
-
-sub new {
-		# Get arguments
-	my ($aType, $aTokenArray) = @_;
-		# Create instance
-	my $self = $aType->SUPER::new;
-		# Reference token array
-	$self->{tokens} = $aTokenArray;
-		# Reference to last added token
-	$self->{_lastAddedToken}     = undef;
-	$self->{_lastAddedTokenType} = undef;
-		# Return instance
-	return $self;
-}  # new()
-
-
-#--- HTML::_TokenTocBeginParser::_processAttributes() -------------------------
-# function: Process attributes.
-# args:     - $aAttributes: Attributes to parse.
-
-sub _processAttributes {
-		# Get arguments
-	my ($self, $aAttributes) = @_;
-		# Local variables
-	my (%includeAttributes, %excludeAttributes, @tocAttributes);
-
-		# Parse attributes
-	$self->_parseAttributes(
-		$aAttributes, \%includeAttributes, \%excludeAttributes, \@tocAttributes
-	);
-		# Include attributes are specified?
-	if (keys(%includeAttributes) > 0) {
-		# Yes, include attributes are specified;
-			# Store include attributes
-		@${$self->{_lastAddedToken}}[
-			HTML::TocGenerator::TT_INCLUDE_ATTRIBUTES_BEGIN
-		] = \%includeAttributes;
-	}
-		# Exclude attributes are specified?
-	if (keys(%excludeAttributes) > 0) {
-		# Yes, exclude attributes are specified;
-			# Store exclude attributes
-		@${$self->{_lastAddedToken}}[
-			HTML::TocGenerator::TT_EXCLUDE_ATTRIBUTES_BEGIN
-		] = \%excludeAttributes;
-	}
-		# Toc attributes are specified?
-	if (@tocAttributes > 0) {
-		# Yes, toc attributes are specified;
-			# Store toc attributes
-		@${$self->{_lastAddedToken}}[
-			HTML::TocGenerator::TT_ATTRIBUTES_TOC
-		] = \@tocAttributes;
-	}
-}  # _processAttributes()
-
-
-#--- HTML::_TokenTocBeginParser::_processToken() ------------------------------
-# function: Process token.
-# args:     - $aTokenType: Type of token to process.
-#           - $aTag: Tag of token.
-
-sub _processToken {
-		# Get arguments
-	my ($self, $aTokenType, $aTag) = @_;
-		# Local variables
-	my ($tokenArray, $index);
-		# Push element on array of update tokens
-	$index = push(@{$self->{tokens}[$aTokenType]}, []) - 1;
-		# Alias token array to add element to
-	$tokenArray = $self->{tokens}[$aTokenType];
-		# Indicate last updated token array element
-	$self->{_lastAddedTokenType} = $aTokenType;
-	$self->{_lastAddedToken}     = \$$tokenArray[$index];
-		# Add fields
-	$$tokenArray[$index][HTML::TocGenerator::TT_TAG_BEGIN] = $aTag;
-	$$tokenArray[$index][HTML::TocGenerator::TT_GROUP]     = $self->{_group};
-	$$tokenArray[$index][HTML::TocGenerator::TT_TOC]       = $self->{_toc};
-}  # _processToken()
-
-
-#--- HTML::_TokenTocBeginParser::comment() ------------------------------------
-# function: Process comment.
-# args:     - $aComment: comment text with '<!--' and '-->' tags stripped off.
-
-sub comment {
-		# Get arguments
-	my ($self, $aComment) = @_;
-		# Process token
-	$self->_processToken(HTML::TocGenerator::TT_TOKENTYPE_COMMENT, $aComment);
-}  # comment()
-
-
-#--- HTML::_TokenTocBeginParser::declaration() --------------------------------
-# function: This function is called every time a markup declaration is
-#           encountered by HTML::Parser.
-# args:     - $aDeclaration: Markup declaration.
-
-sub declaration {
-		# Get arguments
-	my ($self, $aDeclaration) = @_;
-		# Process token
-	$self->_processToken(
-		HTML::TocGenerator::TT_TOKENTYPE_DECLARATION, $aDeclaration
-	);
-}  # declaration()
-
-	
-#--- HTML::_TokenTocBeginParser::end() ----------------------------------------
-# function: This function is called every time a closing tag is encountered
-#           by HTML::Parser.
-# args:     - $aTag: tag name (in lower case).
-
-sub end {
-		# Get arguments
-	my ($self, $aTag, $aOrigText) = @_;
-		# Process token
-	$self->_processToken(HTML::TocGenerator::TT_TOKENTYPE_END, $aTag);
-}  # end()
-
-
-#--- HTML::_TokenTocBeginParser::parse() --------------------------------------
-# function: Parse begin token.
-# args:     - $aToken: 'toc token' to parse
-
-sub parse {
-		# Get arguments
-	my ($self, $aString) = @_;
-		# Call ancestor
-	$self->SUPER::parse($aString);
-}  # parse()
-
-
-#--- HTML::_TokenTocBeginParser->setGroup() -----------------------------------
-# function: Set current 'tokenToToc' group.
-
-sub setGroup {
-		# Get arguments
-	my ($self, $aGroup) = @_;
-		# Set current 'tokenToToc' group
-	$self->{_group} = $aGroup;
-}  # setGroup()
-
-
-#--- HTML::_TokenTocBeginParser->setToc() -------------------------------------
-# function: Set current ToC.
-
-sub setToc {
-		# Get arguments
-	my ($self, $aToc) = @_;
-		# Set current ToC
-	$self->{_toc} = $aToc;
-}  # setToc()
-
-
-#--- HTML::_TokenTocBeginParser::start() --------------------------------------
-# function: This function is called every time an opening tag is encountered.
-# args:     - $aTag: tag name (in lower case).
-#           - $aAttr: reference to hash containing all tag attributes (in lower
-#                case).
-#           - $aAttrSeq: reference to array containing all attribute keys (in 
-#                lower case) in the original order
-#           - $aOrigText: the original HTML text
-
-sub start {
-		# Get arguments
-	my ($self, $aTag, $aAttr, $aAttrSeq, $aOrigText) = @_;
-		# Process token
-	$self->_processToken(HTML::TocGenerator::TT_TOKENTYPE_START, $aTag);
-		# Process attributes
-	$self->_processAttributes($aAttr);
-}  # start()
-
-
-#--- HTML::_TokenTocBeginParser::text() ---------------------------------------
-# function: This function is called every time plain text is encountered.
-# args:     - @_: array containing data.
-
-sub text {
-		# Get arguments
-	my ($self, $aText) = @_;
-		# Was token already created and is last added token of type 'text'?
-	if (
-		defined($self->{_lastAddedToken}) && 
-		$self->{_lastAddedTokenType} == HTML::TocGenerator::TT_TOKENTYPE_TEXT
-	) {
-		# Yes, token is already created;
-			# Add tag to existing token
-		@${$self->{_lastAddedToken}}[HTML::TocGenerator::TT_TAG_BEGIN] .= $aText;
-	}
-	else {
-		# No, token isn't created;
-			# Process token
-		$self->_processToken(HTML::TocGenerator::TT_TOKENTYPE_TEXT, $aText);
-	}
-}  # text()
-
-
-
-
-#=== HTML::_TokenTocEndParser =================================================
-# function: Parse 'toc tokens'.  'Toc tokens' mark HTML code which is to be
-#           inserted into the ToC.
-# note:     Used internally.
-
-package HTML::_TokenTocEndParser;
-
-
-BEGIN {
-	use vars qw(@ISA);
-
-	@ISA = qw(HTML::_TokenTocParser);
-}
-
-
-END {}
-
-
-#--- HTML::_TokenTocEndParser::new() ------------------------------------------
-# function: Constructor
-# args:     - $aType: Class type.
-
-sub new {
-		# Get arguments
-	my ($aType) = @_;
-		# Create instance
-	my $self = $aType->SUPER::new;
-		# Reference to last added token
-	$self->{_lastAddedToken} = undef;
-		# Return instance
-	return $self;
-}  # new()
-
-
-#--- HTML::_TokenTocEndParser::_processAttributes() ---------------------------
-# function: Process attributes.
-# args:     - $aAttributes: Attributes to parse.
-
-sub _processAttributes {
-		# Get arguments
-	my ($self, $aAttributes) = @_;
-		# Local variables
-	my (%includeAttributes, %excludeAttributes);
-
-		# Parse attributes
-	$self->_parseAttributes(
-		$aAttributes, \%includeAttributes, \%excludeAttributes
-	);
-		# Include attributes are specified?
-	if (keys(%includeAttributes) > 0) {
-		# Yes, include attributes are specified;
-			# Store include attributes
-		@${$self->{_Token}}[
-			HTML::TocGenerator::TT_INCLUDE_ATTRIBUTES_END
-		] = \%includeAttributes;
-	}
-		# Exclude attributes are specified?
-	if (keys(%excludeAttributes) > 0) {
-		# Yes, exclude attributes are specified;
-			# Store exclude attributes
-		@${$self->{_Token}}[
-			HTML::TocGenerator::TT_EXCLUDE_ATTRIBUTES_END
-		] = \%excludeAttributes;
-	}
-}  # _processAttributes()
-
-
-#--- HTML::_TokenTocEndParser::_processToken() --------------------------------
-# function: Process token.
-# args:     - $aTokenType: Type of token to process.
-#           - $aTag: Tag of token.
-
-sub _processToken {
-		# Get arguments
-	my ($self, $aTokenType, $aTag) = @_;
-		# Update token
-	@${$self->{_token}}[HTML::TocGenerator::TT_TAG_TYPE_END] = $aTokenType;
-	@${$self->{_token}}[HTML::TocGenerator::TT_TAG_END]      = $aTag;
-		# Indicate token type which has been processed
-	$self->{_lastAddedTokenType} = $aTokenType;
-}  # _processToken()
-
-
-#--- HTML::_TokenTocEndParser::comment() --------------------------------------
-# function: Process comment.
-# args:     - $aComment: comment text with '<!--' and '-->' tags stripped off.
-
-sub comment {
-		# Get arguments
-	my ($self, $aComment) = @_;
-		# Process token
-	$self->_processToken(HTML::TocGenerator::TT_TOKENTYPE_COMMENT, $aComment);
-}  # comment()
-
-
-#--- HTML::_TokenTocDeclarationParser::declaration() --------------------------
-# function: This function is called every time a markup declaration is
-#           encountered by HTML::Parser.
-# args:     - $aDeclaration: Markup declaration.
-
-sub declaration {
-		# Get arguments
-	my ($self, $aDeclaration) = @_;
-		# Process token
-	$self->_processToken(
-		HTML::TocGenerator::TT_TOKENTYPE_DECLARATION, $aDeclaration
-	);
-}  # declaration()
-
-	
-#--- HTML::_TokenTocEndParser::end() ------------------------------------------
-# function: This function is called every time a closing tag is encountered
-#           by HTML::Parser.
-# args:     - $aTag: tag name (in lower case).
-
-sub end {
-		# Get arguments
-	my ($self, $aTag, $aOrigText) = @_;
-		# Process token
-	$self->_processToken(HTML::TocGenerator::TT_TOKENTYPE_END, $aTag);
-}  # end()
-
-
-#--- HTML::_TokenTocEndParser::parse() ----------------------------------------
-# function: Parse token.
-# args:     - $aString: 'toc token' to parse
-#           - $aToken: Reference to token
-#           - $aTokenTypeBegin: Type of begin token
-
-sub parse {
-		# Get arguments
-	my ($self, $aString, $aToken, $aTokenTypeBegin) = @_;
-		# Token argument specified?
-	if (defined($aToken)) {
-		# Yes, token argument is specified;
-			# Store token reference
-		$self->{_token} = $aToken;
-	}
-		# End tag defined?
-	if (! defined($aString)) {
-		# No, end tag isn't defined;
-			# Last added tokentype was of type 'start'?
-		if (
-			(defined($aTokenTypeBegin)) &&
-			($aTokenTypeBegin == HTML::TocGenerator::TT_TOKENTYPE_START) 
-		) {
-			# Yes, last added tokentype was of type 'start';
-				# Assume end tag
-			$self->_processToken(
-				HTML::TocGenerator::TT_TAG_END,
-				@${$self->{_token}}[HTML::TocGenerator::TT_TAG_BEGIN]
-			);
-		}
-	}
-	else {
-			# Call ancestor
-		$self->SUPER::parse($aString);
-	}
-}  # parse()
-
-
-#--- HTML::_TokenTocEndParser::start() ----------------------------------------
-# function: This function is called every time an opening tag is encountered.
-# args:     - $aTag: tag name (in lower case).
-#           - $aAttr: reference to hash containing all tag attributes (in lower
-#                case).
-#           - $aAttrSeq: reference to array containing all attribute keys (in 
-#                lower case) in the original order
-#           - $aOrigText: the original HTML text
-
-sub start {
-		# Get arguments
-	my ($self, $aTag, $aAttr, $aAttrSeq, $aOrigText) = @_;
-		# Process token
-	$self->_processToken(HTML::TocGenerator::TT_TOKENTYPE_START, $aTag);
-		# Process attributes
-	$self->_processAttributes($aAttr);
-}  # start()
-
-
-#--- HTML::_TokenTocEndParser::text() -----------------------------------------
-# function: This function is called every time plain text is encountered.
-# args:     - @_: array containing data.
-
-sub text {
-		# Get arguments
-	my ($self, $aText) = @_;
-
-		# Is token already created?
-	if (defined($self->{_lastAddedTokenType})) {
-		# Yes, token is already created;
-			# Add tag to existing token
-		@${$self->{_token}}[HTML::TocGenerator::TT_TAG_END] .= $aText;
-	}
-	else {
-		# No, token isn't created;
-			# Process token
-		$self->_processToken(HTML::TocGenerator::TT_TOKENTYPE_TEXT, $aText);
-	}
-}  # text()
-
-
-1;