| #==== HTML::TocUpdator ======================================================== | |
| # function: Update 'HTML::Toc' table of contents. | |
| # note: - 'TUT' is an abbreviation of 'Toc Update Token'. | |
| package HTML::TocUpdator; | |
| use strict; | |
| use HTML::TocInsertor; | |
| BEGIN { | |
| use vars qw(@ISA $VERSION); | |
| $VERSION = '0.91'; | |
| @ISA = qw(HTML::TocInsertor); | |
| } | |
| use constant TUT_TOKENTYPE_START => 0; | |
| use constant TUT_TOKENTYPE_END => 1; | |
| use constant TUT_TOKENTYPE_TEXT => 2; | |
| use constant TUT_TOKENTYPE_COMMENT => 3; | |
| use constant MODE_DO_NOTHING => 0; # 0b00 | |
| use constant MODE_DO_INSERT => 1; # 0b01 | |
| use constant MODE_DO_UPDATE => 3; # 0b11 | |
| END {} | |
| #--- HTML::TocUpdator::new() -------------------------------------------------- | |
| # function: Constructor. | |
| sub new { | |
| # Get arguments | |
| my ($aType) = @_; | |
| my $self = $aType->SUPER::new; | |
| # Bias to not update ToC | |
| $self->{htu__Mode} = MODE_DO_NOTHING; | |
| # Bias to not delete tokens | |
| $self->{_doDeleteTokens} = 0; | |
| # Reset batch variables | |
| #$self->_resetBatchVariables; | |
| $self->{options} = {}; | |
| # TODO: Initialize output | |
| return $self; | |
| } # new() | |
| #--- HTML::TocUpdator::_deinitializeUpdatorBatch() -------------------------- | |
| # function: Deinitialize updator batch. | |
| # args: - $aTocs: Reference to array of tocs. | |
| sub _deinitializeUpdatorBatch { | |
| # Get arguments | |
| my ($self, $aTocs) = @_; | |
| # Indicate end of ToC updating | |
| $self->{htu__Mode} = MODE_DO_NOTHING; | |
| # Deinitialize insertor batch | |
| $self->_deinitializeInsertorBatch(); | |
| } # _deinitializeUpdatorBatch() | |
| #--- HTML::TokenUpdator::_doesHashEqualHash() --------------------------------- | |
| # function: Determines whether hash1 equals hash2. | |
| # args: - $aHash1 | |
| # - $aHash2 | |
| # returns: True (1) if hash1 equals hash2, 0 if not. For example, with the | |
| # following hashes: | |
| # | |
| # %hash1 = { %hash2 = { | |
| # 'class' => 'header', 'class' => 'header', | |
| # 'id' => 'intro1' 'id' => 'intro2' | |
| # } } | |
| # | |
| # the routine will return 0, cause the hash fields 'id' differ. | |
| # note: Class function. | |
| sub _doesHashEqualHash { | |
| # Get arguments | |
| my ($aHash1, $aHash2) = @_; | |
| # Local variables | |
| my ($key1, $value1, $key2, $value2, $result); | |
| # Bias to success | |
| $result = 1; | |
| # Loop through hash1 while values available | |
| HASH1: while (($key1, $value1) = each %$aHash1) { | |
| # Yes, values are available; | |
| # Value1 differs from value2? | |
| if ($value1 ne $aHash2->{$key1}) { | |
| # Yes, hashes differ; | |
| # Indicate condition fails | |
| $result = 0; | |
| # Reset 'each' iterator which we're going to break | |
| keys %$aHash2; | |
| # Break loop | |
| last HASH1; | |
| } | |
| } | |
| # Return value | |
| return $result; | |
| } # _doesHashEqualHash() | |
| #--- HTML::TokenUpdator::_doesTagExistInArray() ------------------------------- | |
| # function: Check whether tag & attributes matches any of the tags & attributes | |
| # in the specified array. The array must consist of elements with | |
| # format: | |
| # | |
| # [$tag, \%attributes] | |
| # | |
| # args: - $aTag: tag to search for | |
| # - $aAttributes: tag attributes to search for | |
| # - $aArray: Array to search in. | |
| # returns: 1 if tag does exist in array, 0 if not. | |
| # note: Class function. | |
| sub _doesTagExistInArray { | |
| # Get arguments | |
| my ($aTag, $aAttributes, $aArray) = @_; | |
| # Local variables | |
| my ($tag, $result); | |
| # Bias to non-existing tag | |
| $result = 0; | |
| # Loop through existing tags | |
| TAG: foreach $tag (@{$aArray}) { | |
| if (defined(@{$tag}[0])) { | |
| # Does tag equals any existing tag? | |
| if ($aTag eq @{$tag}[0]) { | |
| # Yes, tag equals existing tag; | |
| # Do hashes equal? | |
| if (HTML::TocUpdator::_doesHashEqualHash( | |
| $aAttributes, @{$tag}[1] | |
| )) { | |
| # Yes, hashes are the same; | |
| # Indicate tag exists in array | |
| $result = 1; | |
| # Break loop | |
| last TAG; | |
| } | |
| } | |
| } | |
| } | |
| # Return value | |
| return $result; | |
| } # _doesTagExistInArray() | |
| #--- HTML::TocUpdator::_initializeUpdatorBatch() ---------------------------- | |
| # function: Initialize insertor batch. | |
| # args: - $aMode: Mode. Can be either MODE_DO_INSERT or MODE_DO_UPDATE | |
| # - $aTocs: Reference to array of tocs. | |
| # - $aOptions: optional options | |
| # note: Updating actually means: deleting the old ToC and inserting a new | |
| # ToC. That's why we're calling 'insertor' methods here. | |
| sub _initializeUpdatorBatch { | |
| # Get arguments | |
| my ($self, $aMode, $aTocs, $aOptions) = @_; | |
| # Initialize insertor batch | |
| $self->_initializeInsertorBatch($aTocs, $aOptions); | |
| # Parse ToC update templates | |
| $self->_parseTocUpdateTokens(); | |
| # Indicate start of ToC updating | |
| $self->{htu__Mode} = $aMode; | |
| } # _initializeUpdatorBatch() | |
| #--- HTML::TocUpdator::_parseTocUpdateTokens() -------------------------------- | |
| # function: Parse ToC insertion point specifier. | |
| sub _parseTocUpdateTokens { | |
| # Get arguments | |
| my ($self) = @_; | |
| # Local variables | |
| my ($toc, $tokenType, $tokenPreposition, $token); | |
| my ($tocInsertionPoint, $tocInsertionPointTokenAttributes); | |
| # Create parser for update begin tokens | |
| my $tokenUpdateBeginParser = HTML::_TokenUpdateParser->new( | |
| $self->{_tokensUpdateBegin} | |
| ); | |
| # Create parser for update end tokens | |
| my $tokenUpdateEndParser = HTML::_TokenUpdateParser->new( | |
| $self->{_tokensUpdateEnd} | |
| ); | |
| # Loop through ToCs | |
| foreach $toc (@{$self->{_tocs}}) { | |
| # Parse update tokens | |
| $tokenUpdateBeginParser->parse( | |
| $toc->{_tokenUpdateBeginOfAnchorNameBegin} | |
| ); | |
| $tokenUpdateBeginParser->parse($toc->{_tokenUpdateBeginOfAnchorNameEnd}); | |
| $tokenUpdateBeginParser->parse($toc->{_tokenUpdateBeginNumber}); | |
| $tokenUpdateBeginParser->parse($toc->{_tokenUpdateBeginToc}); | |
| $tokenUpdateEndParser->parse($toc->{_tokenUpdateEndOfAnchorNameBegin}); | |
| $tokenUpdateEndParser->parse($toc->{_tokenUpdateEndOfAnchorNameEnd}); | |
| $tokenUpdateEndParser->parse($toc->{_tokenUpdateEndNumber}); | |
| $tokenUpdateEndParser->parse($toc->{_tokenUpdateEndToc}); | |
| } | |
| } # _parseTocUpdateTokens() | |
| #--- HTML::TocUpdator::_resetBatchVariables() --------------------------------- | |
| # function: Reset batch variables | |
| sub _resetBatchVariables { | |
| # Get arguments | |
| my ($self) = @_; | |
| # Call ancestor | |
| $self->SUPER::_resetBatchVariables(); | |
| # Arrays containing start, end, comment & text tokens which indicate | |
| # the begin of ToC tokens. The tokens are stored in keys of hashes to | |
| # avoid storing duplicates as an array would. | |
| $self->{_tokensUpdateBegin} = [ | |
| [], # ['<start tag>', <attributes>] | |
| {}, # {'<end tag>' => ''} | |
| {}, # {'<text>' => ''} | |
| {} # {'<comment>' => ''} | |
| ]; | |
| # Arrays containing start, end, comment & text tokens which indicate | |
| # the end of ToC tokens. The tokens are stored in keys of hashes to | |
| # avoid storing duplicates as an array would. | |
| $self->{_tokensUpdateEnd} = [ | |
| [], # ['<start tag>', <attributes>] | |
| {}, # {'<end tag>' => ''} | |
| {}, # {'<text>' => ''} | |
| {} # {'<comment>' => ''} | |
| ]; | |
| } # _resetBatchVariables() | |
| #--- HTML::TocUpdator::_setActiveAnchorName() --------------------------------- | |
| # function: Set active anchor name. | |
| # args: - aAnchorName: Name of anchor name to set active. | |
| sub _setActiveAnchorName { | |
| # Get arguments | |
| my ($self, $aAnchorName) = @_; | |
| # Are tokens being deleted? | |
| if (! $self->{_doDeleteTokens}) { | |
| # No, tokens aren't being deleted; | |
| # Call ancestor to set anchor name | |
| $self->SUPER::_setActiveAnchorName($aAnchorName); | |
| } | |
| } # _setActiveAnchorName() | |
| #--- HTML::TocUpdator::_update() ---------------------------------------------- | |
| # function: Update ToC in string. | |
| # args: - $aMode: Mode. Can be either MODE_DO_UPDATE or MODE_DO_INSERT. | |
| # - $aToc: (reference to array of) ToC object to update | |
| # - $aString: string to update ToC of | |
| # - $aOptions: optional updator options | |
| # note: Used internally. | |
| sub _update { | |
| # Get arguments | |
| my ($self, $aMode, $aToc, $aString, $aOptions) = @_; | |
| # Initialize TocUpdator batch | |
| $self->_initializeUpdatorBatch($aMode, $aToc, $aOptions); | |
| # Start updating ToC by starting ToC insertion | |
| $self->_insert($aString); | |
| # Deinitialize TocUpdator batch | |
| $self->_deinitializeUpdatorBatch(); | |
| } # update() | |
| #--- HTML::TocUpdator::_updateFile() ------------------------------------------ | |
| # function: Update ToCs in file. | |
| # args: - $aMode: Mode. Can be either MODE_DO_UPDATE or MODE_DO_INSERT. | |
| # - $aToc: (reference to array of) ToC object to update | |
| # - $aFile: (reference to array of) file to parse for updating. | |
| # - $aOptions: optional updator options | |
| # note: Used internally. | |
| sub _updateFile { | |
| # Get arguments | |
| my ($self, $aMode, $aToc, $aFile, $aOptions) = @_; | |
| # Initialize TocUpdator batch | |
| $self->_initializeUpdatorBatch($aMode, $aToc, $aOptions); | |
| # Start updating ToC by starting ToC insertion | |
| $self->_insertIntoFile($aFile); | |
| # Deinitialize TocUpdator batch | |
| $self->_deinitializeUpdatorBatch(); | |
| } # _updateFile() | |
| #--- HTML::TocUpdator::_writeOrBufferOutput() --------------------------------- | |
| # function: Write processed HTML to output device(s). | |
| # args: - aOutput: scalar to write | |
| sub _writeOrBufferOutput { | |
| # Get arguments | |
| my ($self, $aOutput) = @_; | |
| # Delete output? | |
| if (! $self->{_doDeleteTokens}) { | |
| # No, don't delete output; | |
| # Call ancestor | |
| $self->SUPER::_writeOrBufferOutput($aOutput); | |
| } | |
| } # _writeOrBufferOutput() | |
| #--- HTML::TocUpdator::anchorNameBegin() -------------------------------------- | |
| # function: Process 'anchor name begin' generated by HTML::Toc. | |
| # args: - $aAnchorName: Anchor name begin tag to output. | |
| # - $aToc: Reference to ToC to which anchorname belongs. | |
| sub anchorNameBegin { | |
| # Get arguments | |
| my ($self, $aAnchorNameBegin, $aToc) = @_; | |
| # Call ancestor | |
| $self->SUPER::anchorNameBegin($aAnchorNameBegin); | |
| # Must ToC be inserted or updated? | |
| if ($self->{htu__Mode} != MODE_DO_NOTHING) { | |
| # Yes, ToC must be inserted or updated; | |
| # Surround anchor name with update tags | |
| $self->{_outputPrefix} = | |
| $aToc->{_tokenUpdateBeginOfAnchorNameBegin} . | |
| $self->{_outputPrefix} . | |
| $aToc->{_tokenUpdateEndOfAnchorNameBegin}; | |
| } | |
| } # anchorNameBegin() | |
| #--- HTML::TocUpdator::anchorNameEnd() ---------------------------------------- | |
| # function: Process 'anchor name end' generated by HTML::Toc. | |
| # args: - $aAnchorNameEnd: Anchor name end tag to output. | |
| # - $aToc: Reference to ToC to which anchorname belongs. | |
| sub anchorNameEnd { | |
| # Get arguments | |
| my ($self, $aAnchorNameEnd, $aToc) = @_; | |
| # Call ancestor | |
| $self->SUPER::anchorNameEnd($aAnchorNameEnd); | |
| # Must ToC be inserted or updated? | |
| if ($self->{htu__Mode} != MODE_DO_NOTHING) { | |
| # Yes, ToC must be inserted or updated; | |
| # Surround anchor name with update tags | |
| $self->{_outputSuffix} = | |
| $aToc->{_tokenUpdateBeginOfAnchorNameEnd} . | |
| $self->{_outputSuffix} . | |
| $aToc->{_tokenUpdateEndOfAnchorNameEnd}; | |
| } | |
| } # anchorNameEnd() | |
| #--- HTML::TocUpdator::comment() ---------------------------------------------- | |
| # function: Process comment. | |
| # args: - $aComment: comment text with '<!--' and '-->' tags stripped off. | |
| sub comment { | |
| # Get arguments | |
| my ($self, $aComment) = @_; | |
| # Must ToC be updated? | |
| if ($self->{htu__Mode} == MODE_DO_UPDATE) { | |
| # Yes, ToC must be updated; | |
| # Updator is currently deleting tokens? | |
| if ($self->{_doDeleteTokens}) { | |
| # Yes, tokens must be deleted; | |
| # Call ancestor | |
| $self->SUPER::comment($aComment); | |
| # Look for update end token | |
| # Does comment matches update end token? | |
| if (defined( | |
| $self->{_tokensUpdateEnd}[TUT_TOKENTYPE_COMMENT]{$aComment} | |
| )) { | |
| # Yes, comment matches update end token; | |
| # Indicate to stop deleting tokens | |
| $self->{_doDeleteTokens} = 0; | |
| } | |
| } | |
| else { | |
| # No, tokens mustn't be deleted; | |
| # Look for update begin token | |
| # Does comment matches update begin token? | |
| if (defined( | |
| $self->{_tokensUpdateBegin}[TUT_TOKENTYPE_COMMENT]{$aComment} | |
| )) { | |
| # Yes, comment matches update begin token; | |
| # Indicate to start deleting tokens | |
| $self->{_doDeleteTokens} = 1; | |
| } | |
| # Call ancestor | |
| $self->SUPER::comment($aComment); | |
| } | |
| } | |
| else { | |
| # No, ToC mustn't be updated; | |
| # Call ancestor | |
| $self->SUPER::comment($aComment); | |
| } | |
| } # comment() | |
| #--- HTML::TocUpdator::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) = @_; | |
| # Call ancestor | |
| $self->SUPER::end($aTag, $aOrigText); | |
| # Must ToC be updated? | |
| if ($self->{htu__Mode} == MODE_DO_UPDATE) { | |
| # Yes, ToC must be updated; | |
| # Updator is currently deleting tokens? | |
| if ($self->{_doDeleteTokens}) { | |
| # Yes, tokens must be deleted; | |
| # Does end tag matches update end token? | |
| if (defined( | |
| $self->{_tokensUpdateEnd}[TUT_TOKENTYPE_END]{$aTag} | |
| )) { | |
| # Yes, end tag matches update end token; | |
| # Indicate to stop deleting tokens | |
| $self->{_doDeleteTokens} = 0; | |
| } | |
| } | |
| } | |
| } # end() | |
| #--- HTML::TocUpdator::insert() ----------------------------------------------- | |
| # function: Insert ToC in string. | |
| # args: - $aToc: (reference to array of) ToC object to update | |
| # - $aString: string to insert ToC in. | |
| # - $aOptions: optional updator options | |
| sub insert { | |
| # Get arguments | |
| my ($self, $aToc, $aString, $aOptions) = @_; | |
| # Do start insert | |
| $self->_update(MODE_DO_INSERT, $aToc, $aString, $aOptions); | |
| } # insert() | |
| #--- HTML::TocUpdator::insertIntoFile() -------------------------------------- | |
| # function: Insert ToC in file. | |
| # args: - $aToc: (reference to array of) ToC object to update | |
| # - $aFile: File to insert ToC in. | |
| # - $aOptions: optional updator options | |
| sub insertIntoFile { | |
| # Get arguments | |
| my ($self, $aToc, $aFile, $aOptions) = @_; | |
| # Do start insert | |
| $self->_updateFile(MODE_DO_INSERT, $aToc, $aFile, $aOptions); | |
| } # insertIntoFile() | |
| #--- HTML::TocUpdator::number() ----------------------------------------------- | |
| # function: Process heading number generated by HTML::Toc. | |
| # args: - $aNumber | |
| # - $aToc: Reference to ToC to which anchorname belongs. | |
| sub number { | |
| # Get arguments | |
| my ($self, $aNumber, $aToc) = @_; | |
| # Call ancestor | |
| $self->SUPER::number($aNumber); | |
| # Must ToC be inserted or updated? | |
| if ($self->{htu__Mode} != MODE_DO_NOTHING) { | |
| # Yes, ToC must be inserted or updated; | |
| # Surround number with update tags | |
| $self->{_outputSuffix} = | |
| $aToc->{_tokenUpdateBeginNumber} . | |
| $self->{_outputSuffix} . | |
| $aToc->{_tokenUpdateEndNumber}; | |
| } | |
| } # number() | |
| #--- HTML::TocUpdator::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) = @_; | |
| # Must ToC be updated? | |
| if ($self->{htu__Mode} == MODE_DO_UPDATE) { | |
| # Yes, ToC must be updated; | |
| # Does start tag matches token update begin tag? | |
| if (HTML::TocUpdator::_doesTagExistInArray( | |
| $aTag, $aAttr, $self->{_tokensUpdateBegin}[TUT_TOKENTYPE_START] | |
| )) { | |
| # Yes, start tag matches token update tag; | |
| # Indicate to delete tokens | |
| $self->{_doDeleteTokens} = 1; | |
| } | |
| } | |
| # Let ancestor process the start tag | |
| $self->SUPER::start($aTag, $aAttr, $aAttrSeq, $aOrigText); | |
| } # start() | |
| #--- HTML::TocUpdator::toc() -------------------------------------------------- | |
| # function: Toc processing method. Add toc reference to scenario. | |
| # args: - $aScenario: Scenario to add ToC reference to. | |
| # - $aToc: Reference to ToC to insert. | |
| # note: The ToC hasn't been build yet; only a reference to the ToC to be | |
| # build is inserted. | |
| sub toc { | |
| # Get arguments | |
| my ($self, $aScenario, $aToc) = @_; | |
| # Surround toc with update tokens | |
| # Add update begin token | |
| push(@$aScenario, \$aToc->{_tokenUpdateBeginToc}); | |
| # Call ancestor | |
| $self->SUPER::toc($aScenario, $aToc); | |
| # Add update end token | |
| push(@$aScenario, \$aToc->{_tokenUpdateEndToc}); | |
| } # toc() | |
| #--- HTML::TocUpdator::_processTocText() -------------------------------------- | |
| # function: Toc text processing function. | |
| # args: - $aText: Text to add to ToC. | |
| # - $aToc: ToC to add text to. | |
| sub _processTocText { | |
| # Get arguments | |
| my ($self, $aText, $aToc) = @_; | |
| # Delete output? | |
| if (! $self->{_doDeleteTokens}) { | |
| # No, don't delete output; | |
| # Call ancestor | |
| $self->SUPER::_processTocText($aText, $aToc); | |
| } | |
| } # _processTocText() | |
| #--- HTML::TocUpdator::update() ----------------------------------------------- | |
| # function: Update ToC in string. | |
| # args: - $aToc: (reference to array of) ToC object to update | |
| # - $aString: string to update ToC of | |
| # - $aOptions: optional updator options | |
| sub update { | |
| # Get arguments | |
| my ($self, $aToc, $aString, $aOptions) = @_; | |
| # Do start update | |
| $self->_update(MODE_DO_UPDATE, $aToc, $aString, $aOptions); | |
| } # update() | |
| #--- HTML::TocUpdator::updateFile() ------------------------------------------- | |
| # function: Update ToC of file. | |
| # args: - $aToc: (reference to array of) ToC object to update | |
| # - $aFile: (reference to array of) file to parse for updating. | |
| # - $aOptions: optional updator options | |
| sub updateFile { | |
| # Get arguments | |
| my ($self, $aToc, $aFile, $aOptions) = @_; | |
| # Do start update | |
| $self->_updateFile(MODE_DO_UPDATE, $aToc, $aFile, $aOptions); | |
| } # update() | |
| #=== HTML::_TokenUpdateParser ================================================= | |
| # function: Parse 'update tokens'. 'Update tokens' mark HTML code which is | |
| # inserted by 'HTML::TocInsertor'. | |
| # note: Used internally. | |
| package HTML::_TokenUpdateParser; | |
| BEGIN { | |
| use vars qw(@ISA); | |
| @ISA = qw(HTML::Parser); | |
| } | |
| END {} | |
| #--- HTML::_TokenUpdateParser::new() ------------------------------------------ | |
| # function: Constructor | |
| sub new { | |
| # Get arguments | |
| my ($aType, $aTokenArray) = @_; | |
| # Create instance | |
| my $self = $aType->SUPER::new; | |
| # Reference token array | |
| $self->{tokens} = $aTokenArray; | |
| # Return instance | |
| return $self; | |
| } # new() | |
| #--- HTML::_TokenUpdateParser::comment() -------------------------------------- | |
| # function: Process comment. | |
| # args: - $aComment: comment text with '<!--' and '-->' tags stripped off. | |
| sub comment { | |
| # Get arguments | |
| my ($self, $aComment) = @_; | |
| # Add token to array of update tokens | |
| $self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_COMMENT]{$aComment} = ''; | |
| } # comment() | |
| #--- HTML::_TokenUpdateParser::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) = @_; | |
| # Add token to array of update tokens | |
| $self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_END]{$aTag} = ''; | |
| } # end() | |
| #--- HTML::_TokenUpdateParser::parse() ---------------------------------------- | |
| # function: Parse token. | |
| # args: - $aToken: 'update token' to parse | |
| sub parse { | |
| # Get arguments | |
| my ($self, $aString) = @_; | |
| # Call ancestor | |
| $self->SUPER::parse($aString); | |
| } # parse() | |
| #--- HTML::_TokenUpdateParser::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) = @_; | |
| # Does token exist in array? | |
| if (! HTML::TocUpdator::_doesTagExistInArray( | |
| $aTag, $aAttr, $self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_START] | |
| )) { | |
| # No, token doesn't exist in array; | |
| # Add token to array of update tokens | |
| push( | |
| @{$self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_START]}, | |
| [$aTag, $aAttr] | |
| ); | |
| } | |
| } # start() | |
| #--- HTML::_TokenUpdateParser::text() ----------------------------------------- | |
| # function: This function is called every time plain text is encountered. | |
| # args: - @_: array containing data. | |
| sub text { | |
| # Get arguments | |
| my ($self, $aText) = @_; | |
| # Add token to array of update tokens | |
| $self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_TEXT]{$aText} = ''; | |
| } # text() | |
| 1; |