| #=== 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  "'; | |
| 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; |