1 #==== HTML::TocUpdator ======================================================== 2 # function: Update 'HTML::Toc' table of contents. 3 # note: - 'TUT' is an abbreviation of 'Toc Update Token'. 4 5 6 package HTML::TocUpdator; 7 8 9 use strict; 10 use HTML::TocInsertor; 11 12 13 BEGIN { 14 use vars qw(@ISA $VERSION); 15 16 $VERSION = '0.91'; 17 18 @ISA = qw(HTML::TocInsertor); 19 } 20 21 22 use constant TUT_TOKENTYPE_START => 0; 23 use constant TUT_TOKENTYPE_END => 1; 24 use constant TUT_TOKENTYPE_TEXT => 2; 25 use constant TUT_TOKENTYPE_COMMENT => 3; 26 27 use constant MODE_DO_NOTHING => 0; # 0b00 28 use constant MODE_DO_INSERT => 1; # 0b01 29 use constant MODE_DO_UPDATE => 3; # 0b11 30 31 32 END {} 33 34 35 #--- HTML::TocUpdator::new() -------------------------------------------------- 36 # function: Constructor. 37 38 sub new { 39 # Get arguments 40 my ($aType) = @_; 41 my $self = $aType->SUPER::new; 42 # Bias to not update ToC 43 $self->{htu__Mode} = MODE_DO_NOTHING; 44 # Bias to not delete tokens 45 $self->{_doDeleteTokens} = 0; 46 # Reset batch variables 47 #$self->_resetBatchVariables; 48 49 $self->{options} = {}; 50 51 # TODO: Initialize output 52 53 return $self; 54 } # new() 55 56 57 #--- HTML::TocUpdator::_deinitializeUpdatorBatch() -------------------------- 58 # function: Deinitialize updator batch. 59 # args: - $aTocs: Reference to array of tocs. 60 61 sub _deinitializeUpdatorBatch { 62 # Get arguments 63 my ($self, $aTocs) = @_; 64 # Indicate end of ToC updating 65 $self->{htu__Mode} = MODE_DO_NOTHING; 66 # Deinitialize insertor batch 67 $self->_deinitializeInsertorBatch(); 68 } # _deinitializeUpdatorBatch() 69 70 71 #--- HTML::TokenUpdator::_doesHashEqualHash() --------------------------------- 72 # function: Determines whether hash1 equals hash2. 73 # args: - $aHash1 74 # - $aHash2 75 # returns: True (1) if hash1 equals hash2, 0 if not. For example, with the 76 # following hashes: 77 # 78 # %hash1 = { %hash2 = { 79 # 'class' => 'header', 'class' => 'header', 80 # 'id' => 'intro1' 'id' => 'intro2' 81 # } } 82 # 83 # the routine will return 0, cause the hash fields 'id' differ. 84 # note: Class function. 85 86 sub _doesHashEqualHash { 87 # Get arguments 88 my ($aHash1, $aHash2) = @_; 89 # Local variables 90 my ($key1, $value1, $key2, $value2, $result); 91 # Bias to success 92 $result = 1; 93 # Loop through hash1 while values available 94 HASH1: while (($key1, $value1) = each %$aHash1) { 95 # Yes, values are available; 96 # Value1 differs from value2? 97 if ($value1 ne $aHash2->{$key1}) { 98 # Yes, hashes differ; 99 # Indicate condition fails 100 $result = 0; 101 # Reset 'each' iterator which we're going to break 102 keys %$aHash2; 103 # Break loop 104 last HASH1; 105 } 106 } 107 # Return value 108 return $result; 109 } # _doesHashEqualHash() 110 111 112 #--- HTML::TokenUpdator::_doesTagExistInArray() ------------------------------- 113 # function: Check whether tag & attributes matches any of the tags & attributes 114 # in the specified array. The array must consist of elements with 115 # format: 116 # 117 # [$tag, \%attributes] 118 # 119 # args: - $aTag: tag to search for 120 # - $aAttributes: tag attributes to search for 121 # - $aArray: Array to search in. 122 # returns: 1 if tag does exist in array, 0 if not. 123 # note: Class function. 124 125 sub _doesTagExistInArray { 126 # Get arguments 127 my ($aTag, $aAttributes, $aArray) = @_; 128 # Local variables 129 my ($tag, $result); 130 # Bias to non-existing tag 131 $result = 0; 132 # Loop through existing tags 133 TAG: foreach $tag (@{$aArray}) { 134 if (defined(@{$tag}[0])) { 135 # Does tag equals any existing tag? 136 if ($aTag eq @{$tag}[0]) { 137 # Yes, tag equals existing tag; 138 # Do hashes equal? 139 if (HTML::TocUpdator::_doesHashEqualHash( 140 $aAttributes, @{$tag}[1] 141 )) { 142 # Yes, hashes are the same; 143 # Indicate tag exists in array 144 $result = 1; 145 # Break loop 146 last TAG; 147 } 148 } 149 } 150 } 151 # Return value 152 return $result; 153 } # _doesTagExistInArray() 154 155 156 #--- HTML::TocUpdator::_initializeUpdatorBatch() ---------------------------- 157 # function: Initialize insertor batch. 158 # args: - $aMode: Mode. Can be either MODE_DO_INSERT or MODE_DO_UPDATE 159 # - $aTocs: Reference to array of tocs. 160 # - $aOptions: optional options 161 # note: Updating actually means: deleting the old ToC and inserting a new 162 # ToC. That's why we're calling 'insertor' methods here. 163 164 sub _initializeUpdatorBatch { 165 # Get arguments 166 my ($self, $aMode, $aTocs, $aOptions) = @_; 167 # Initialize insertor batch 168 $self->_initializeInsertorBatch($aTocs, $aOptions); 169 # Parse ToC update templates 170 $self->_parseTocUpdateTokens(); 171 # Indicate start of ToC updating 172 $self->{htu__Mode} = $aMode; 173 } # _initializeUpdatorBatch() 174 175 176 #--- HTML::TocUpdator::_parseTocUpdateTokens() -------------------------------- 177 # function: Parse ToC insertion point specifier. 178 179 sub _parseTocUpdateTokens { 180 # Get arguments 181 my ($self) = @_; 182 # Local variables 183 my ($toc, $tokenType, $tokenPreposition, $token); 184 my ($tocInsertionPoint, $tocInsertionPointTokenAttributes); 185 # Create parser for update begin tokens 186 my $tokenUpdateBeginParser = HTML::_TokenUpdateParser->new( 187 $self->{_tokensUpdateBegin} 188 ); 189 # Create parser for update end tokens 190 my $tokenUpdateEndParser = HTML::_TokenUpdateParser->new( 191 $self->{_tokensUpdateEnd} 192 ); 193 194 # Loop through ToCs 195 foreach $toc (@{$self->{_tocs}}) { 196 # Parse update tokens 197 $tokenUpdateBeginParser->parse( 198 $toc->{_tokenUpdateBeginOfAnchorNameBegin} 199 ); 200 $tokenUpdateBeginParser->parse($toc->{_tokenUpdateBeginOfAnchorNameEnd}); 201 $tokenUpdateBeginParser->parse($toc->{_tokenUpdateBeginNumber}); 202 $tokenUpdateBeginParser->parse($toc->{_tokenUpdateBeginToc}); 203 204 $tokenUpdateEndParser->parse($toc->{_tokenUpdateEndOfAnchorNameBegin}); 205 $tokenUpdateEndParser->parse($toc->{_tokenUpdateEndOfAnchorNameEnd}); 206 $tokenUpdateEndParser->parse($toc->{_tokenUpdateEndNumber}); 207 $tokenUpdateEndParser->parse($toc->{_tokenUpdateEndToc}); 208 } 209 } # _parseTocUpdateTokens() 210 211 212 #--- HTML::TocUpdator::_resetBatchVariables() --------------------------------- 213 # function: Reset batch variables 214 215 sub _resetBatchVariables { 216 # Get arguments 217 my ($self) = @_; 218 # Call ancestor 219 $self->SUPER::_resetBatchVariables(); 220 # Arrays containing start, end, comment & text tokens which indicate 221 # the begin of ToC tokens. The tokens are stored in keys of hashes to 222 # avoid storing duplicates as an array would. 223 $self->{_tokensUpdateBegin} = [ 224 [], # ['<start tag>', <attributes>] 225 {}, # {'<end tag>' => ''} 226 {}, # {'<text>' => ''} 227 {} # {'<comment>' => ''} 228 ]; 229 # Arrays containing start, end, comment & text tokens which indicate 230 # the end of ToC tokens. The tokens are stored in keys of hashes to 231 # avoid storing duplicates as an array would. 232 $self->{_tokensUpdateEnd} = [ 233 [], # ['<start tag>', <attributes>] 234 {}, # {'<end tag>' => ''} 235 {}, # {'<text>' => ''} 236 {} # {'<comment>' => ''} 237 ]; 238 } # _resetBatchVariables() 239 240 241 #--- HTML::TocUpdator::_setActiveAnchorName() --------------------------------- 242 # function: Set active anchor name. 243 # args: - aAnchorName: Name of anchor name to set active. 244 245 sub _setActiveAnchorName { 246 # Get arguments 247 my ($self, $aAnchorName) = @_; 248 # Are tokens being deleted? 249 if (! $self->{_doDeleteTokens}) { 250 # No, tokens aren't being deleted; 251 # Call ancestor to set anchor name 252 $self->SUPER::_setActiveAnchorName($aAnchorName); 253 } 254 } # _setActiveAnchorName() 255 256 257 #--- HTML::TocUpdator::_update() ---------------------------------------------- 258 # function: Update ToC in string. 259 # args: - $aMode: Mode. Can be either MODE_DO_UPDATE or MODE_DO_INSERT. 260 # - $aToc: (reference to array of) ToC object to update 261 # - $aString: string to update ToC of 262 # - $aOptions: optional updator options 263 # note: Used internally. 264 265 sub _update { 266 # Get arguments 267 my ($self, $aMode, $aToc, $aString, $aOptions) = @_; 268 # Initialize TocUpdator batch 269 $self->_initializeUpdatorBatch($aMode, $aToc, $aOptions); 270 # Start updating ToC by starting ToC insertion 271 $self->_insert($aString); 272 # Deinitialize TocUpdator batch 273 $self->_deinitializeUpdatorBatch(); 274 } # update() 275 276 277 #--- HTML::TocUpdator::_updateFile() ------------------------------------------ 278 # function: Update ToCs in file. 279 # args: - $aMode: Mode. Can be either MODE_DO_UPDATE or MODE_DO_INSERT. 280 # - $aToc: (reference to array of) ToC object to update 281 # - $aFile: (reference to array of) file to parse for updating. 282 # - $aOptions: optional updator options 283 # note: Used internally. 284 285 sub _updateFile { 286 # Get arguments 287 my ($self, $aMode, $aToc, $aFile, $aOptions) = @_; 288 # Initialize TocUpdator batch 289 $self->_initializeUpdatorBatch($aMode, $aToc, $aOptions); 290 # Start updating ToC by starting ToC insertion 291 $self->_insertIntoFile($aFile); 292 # Deinitialize TocUpdator batch 293 $self->_deinitializeUpdatorBatch(); 294 } # _updateFile() 295 296 297 #--- HTML::TocUpdator::_writeOrBufferOutput() --------------------------------- 298 # function: Write processed HTML to output device(s). 299 # args: - aOutput: scalar to write 300 301 sub _writeOrBufferOutput { 302 # Get arguments 303 my ($self, $aOutput) = @_; 304 # Delete output? 305 if (! $self->{_doDeleteTokens}) { 306 # No, don't delete output; 307 # Call ancestor 308 $self->SUPER::_writeOrBufferOutput($aOutput); 309 } 310 } # _writeOrBufferOutput() 311 312 313 #--- HTML::TocUpdator::anchorNameBegin() -------------------------------------- 314 # function: Process 'anchor name begin' generated by HTML::Toc. 315 # args: - $aAnchorName: Anchor name begin tag to output. 316 # - $aToc: Reference to ToC to which anchorname belongs. 317 318 sub anchorNameBegin { 319 # Get arguments 320 my ($self, $aAnchorNameBegin, $aToc) = @_; 321 # Call ancestor 322 $self->SUPER::anchorNameBegin($aAnchorNameBegin); 323 # Must ToC be inserted or updated? 324 if ($self->{htu__Mode} != MODE_DO_NOTHING) { 325 # Yes, ToC must be inserted or updated; 326 # Surround anchor name with update tags 327 $self->{_outputPrefix} = 328 $aToc->{_tokenUpdateBeginOfAnchorNameBegin} . 329 $self->{_outputPrefix} . 330 $aToc->{_tokenUpdateEndOfAnchorNameBegin}; 331 } 332 } # anchorNameBegin() 333 334 335 #--- HTML::TocUpdator::anchorNameEnd() ---------------------------------------- 336 # function: Process 'anchor name end' generated by HTML::Toc. 337 # args: - $aAnchorNameEnd: Anchor name end tag to output. 338 # - $aToc: Reference to ToC to which anchorname belongs. 339 340 sub anchorNameEnd { 341 # Get arguments 342 my ($self, $aAnchorNameEnd, $aToc) = @_; 343 # Call ancestor 344 $self->SUPER::anchorNameEnd($aAnchorNameEnd); 345 # Must ToC be inserted or updated? 346 if ($self->{htu__Mode} != MODE_DO_NOTHING) { 347 # Yes, ToC must be inserted or updated; 348 # Surround anchor name with update tags 349 $self->{_outputSuffix} = 350 $aToc->{_tokenUpdateBeginOfAnchorNameEnd} . 351 $self->{_outputSuffix} . 352 $aToc->{_tokenUpdateEndOfAnchorNameEnd}; 353 } 354 } # anchorNameEnd() 355 356 357 #--- HTML::TocUpdator::comment() ---------------------------------------------- 358 # function: Process comment. 359 # args: - $aComment: comment text with '<!--' and '-->' tags stripped off. 360 361 sub comment { 362 # Get arguments 363 my ($self, $aComment) = @_; 364 # Must ToC be updated? 365 if ($self->{htu__Mode} == MODE_DO_UPDATE) { 366 # Yes, ToC must be updated; 367 # Updator is currently deleting tokens? 368 if ($self->{_doDeleteTokens}) { 369 # Yes, tokens must be deleted; 370 # Call ancestor 371 $self->SUPER::comment($aComment); 372 373 # Look for update end token 374 375 # Does comment matches update end token? 376 if (defined( 377 $self->{_tokensUpdateEnd}[TUT_TOKENTYPE_COMMENT]{$aComment} 378 )) { 379 # Yes, comment matches update end token; 380 # Indicate to stop deleting tokens 381 $self->{_doDeleteTokens} = 0; 382 } 383 } 384 else { 385 # No, tokens mustn't be deleted; 386 387 # Look for update begin token 388 389 # Does comment matches update begin token? 390 if (defined( 391 $self->{_tokensUpdateBegin}[TUT_TOKENTYPE_COMMENT]{$aComment} 392 )) { 393 # Yes, comment matches update begin token; 394 # Indicate to start deleting tokens 395 $self->{_doDeleteTokens} = 1; 396 } 397 # Call ancestor 398 $self->SUPER::comment($aComment); 399 } 400 } 401 else { 402 # No, ToC mustn't be updated; 403 # Call ancestor 404 $self->SUPER::comment($aComment); 405 } 406 } # comment() 407 408 409 #--- HTML::TocUpdator::end() -------------------------------------------------- 410 # function: This function is called every time a closing tag is encountered. 411 # args: - $aTag: tag name (in lower case). 412 # - $aOrigText: tag name including brackets. 413 414 sub end { 415 # Get arguments 416 my ($self, $aTag, $aOrigText) = @_; 417 # Call ancestor 418 $self->SUPER::end($aTag, $aOrigText); 419 # Must ToC be updated? 420 if ($self->{htu__Mode} == MODE_DO_UPDATE) { 421 # Yes, ToC must be updated; 422 # Updator is currently deleting tokens? 423 if ($self->{_doDeleteTokens}) { 424 # Yes, tokens must be deleted; 425 # Does end tag matches update end token? 426 if (defined( 427 $self->{_tokensUpdateEnd}[TUT_TOKENTYPE_END]{$aTag} 428 )) { 429 # Yes, end tag matches update end token; 430 # Indicate to stop deleting tokens 431 $self->{_doDeleteTokens} = 0; 432 } 433 } 434 } 435 } # end() 436 437 438 #--- HTML::TocUpdator::insert() ----------------------------------------------- 439 # function: Insert ToC in string. 440 # args: - $aToc: (reference to array of) ToC object to update 441 # - $aString: string to insert ToC in. 442 # - $aOptions: optional updator options 443 444 sub insert { 445 # Get arguments 446 my ($self, $aToc, $aString, $aOptions) = @_; 447 # Do start insert 448 $self->_update(MODE_DO_INSERT, $aToc, $aString, $aOptions); 449 } # insert() 450 451 452 #--- HTML::TocUpdator::insertIntoFile() -------------------------------------- 453 # function: Insert ToC in file. 454 # args: - $aToc: (reference to array of) ToC object to update 455 # - $aFile: File to insert ToC in. 456 # - $aOptions: optional updator options 457 458 sub insertIntoFile { 459 # Get arguments 460 my ($self, $aToc, $aFile, $aOptions) = @_; 461 # Do start insert 462 $self->_updateFile(MODE_DO_INSERT, $aToc, $aFile, $aOptions); 463 } # insertIntoFile() 464 465 466 #--- HTML::TocUpdator::number() ----------------------------------------------- 467 # function: Process heading number generated by HTML::Toc. 468 # args: - $aNumber 469 # - $aToc: Reference to ToC to which anchorname belongs. 470 471 sub number { 472 # Get arguments 473 my ($self, $aNumber, $aToc) = @_; 474 # Call ancestor 475 $self->SUPER::number($aNumber); 476 # Must ToC be inserted or updated? 477 if ($self->{htu__Mode} != MODE_DO_NOTHING) { 478 # Yes, ToC must be inserted or updated; 479 # Surround number with update tags 480 $self->{_outputSuffix} = 481 $aToc->{_tokenUpdateBeginNumber} . 482 $self->{_outputSuffix} . 483 $aToc->{_tokenUpdateEndNumber}; 484 } 485 } # number() 486 487 488 #--- HTML::TocUpdator::start() ------------------------------------------------ 489 # function: This function is called every time an opening tag is encountered. 490 # args: - $aTag: tag name (in lower case). 491 # - $aAttr: reference to hash containing all tag attributes (in lower 492 # case). 493 # - $aAttrSeq: reference to array containing all tag attributes (in 494 # lower case) in the original order 495 # - $aOrigText: the original HTML text 496 497 sub start { 498 # Get arguments 499 my ($self, $aTag, $aAttr, $aAttrSeq, $aOrigText) = @_; 500 # Must ToC be updated? 501 if ($self->{htu__Mode} == MODE_DO_UPDATE) { 502 # Yes, ToC must be updated; 503 # Does start tag matches token update begin tag? 504 if (HTML::TocUpdator::_doesTagExistInArray( 505 $aTag, $aAttr, $self->{_tokensUpdateBegin}[TUT_TOKENTYPE_START] 506 )) { 507 # Yes, start tag matches token update tag; 508 # Indicate to delete tokens 509 $self->{_doDeleteTokens} = 1; 510 } 511 } 512 # Let ancestor process the start tag 513 $self->SUPER::start($aTag, $aAttr, $aAttrSeq, $aOrigText); 514 } # start() 515 516 517 #--- HTML::TocUpdator::toc() -------------------------------------------------- 518 # function: Toc processing method. Add toc reference to scenario. 519 # args: - $aScenario: Scenario to add ToC reference to. 520 # - $aToc: Reference to ToC to insert. 521 # note: The ToC hasn't been build yet; only a reference to the ToC to be 522 # build is inserted. 523 524 sub toc { 525 # Get arguments 526 my ($self, $aScenario, $aToc) = @_; 527 528 # Surround toc with update tokens 529 530 # Add update begin token 531 push(@$aScenario, \$aToc->{_tokenUpdateBeginToc}); 532 # Call ancestor 533 $self->SUPER::toc($aScenario, $aToc); 534 # Add update end token 535 push(@$aScenario, \$aToc->{_tokenUpdateEndToc}); 536 } # toc() 537 538 539 #--- HTML::TocUpdator::_processTocText() -------------------------------------- 540 # function: Toc text processing function. 541 # args: - $aText: Text to add to ToC. 542 # - $aToc: ToC to add text to. 543 544 sub _processTocText { 545 # Get arguments 546 my ($self, $aText, $aToc) = @_; 547 # Delete output? 548 if (! $self->{_doDeleteTokens}) { 549 # No, don't delete output; 550 # Call ancestor 551 $self->SUPER::_processTocText($aText, $aToc); 552 } 553 } # _processTocText() 554 555 556 #--- HTML::TocUpdator::update() ----------------------------------------------- 557 # function: Update ToC in string. 558 # args: - $aToc: (reference to array of) ToC object to update 559 # - $aString: string to update ToC of 560 # - $aOptions: optional updator options 561 562 sub update { 563 # Get arguments 564 my ($self, $aToc, $aString, $aOptions) = @_; 565 # Do start update 566 $self->_update(MODE_DO_UPDATE, $aToc, $aString, $aOptions); 567 } # update() 568 569 570 #--- HTML::TocUpdator::updateFile() ------------------------------------------- 571 # function: Update ToC of file. 572 # args: - $aToc: (reference to array of) ToC object to update 573 # - $aFile: (reference to array of) file to parse for updating. 574 # - $aOptions: optional updator options 575 576 sub updateFile { 577 # Get arguments 578 my ($self, $aToc, $aFile, $aOptions) = @_; 579 # Do start update 580 $self->_updateFile(MODE_DO_UPDATE, $aToc, $aFile, $aOptions); 581 } # update() 582 583 584 585 586 #=== HTML::_TokenUpdateParser ================================================= 587 # function: Parse 'update tokens'. 'Update tokens' mark HTML code which is 588 # inserted by 'HTML::TocInsertor'. 589 # note: Used internally. 590 591 package HTML::_TokenUpdateParser; 592 593 594 BEGIN { 595 use vars qw(@ISA); 596 597 @ISA = qw(HTML::Parser); 598 } 599 600 END {} 601 602 603 #--- HTML::_TokenUpdateParser::new() ------------------------------------------ 604 # function: Constructor 605 606 sub new { 607 # Get arguments 608 my ($aType, $aTokenArray) = @_; 609 # Create instance 610 my $self = $aType->SUPER::new; 611 # Reference token array 612 $self->{tokens} = $aTokenArray; 613 # Return instance 614 return $self; 615 } # new() 616 617 618 #--- HTML::_TokenUpdateParser::comment() -------------------------------------- 619 # function: Process comment. 620 # args: - $aComment: comment text with '<!--' and '-->' tags stripped off. 621 622 sub comment { 623 # Get arguments 624 my ($self, $aComment) = @_; 625 # Add token to array of update tokens 626 $self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_COMMENT]{$aComment} = ''; 627 } # comment() 628 629 630 #--- HTML::_TokenUpdateParser::end() ------------------------------------------ 631 # function: This function is called every time a closing tag is encountered 632 # by HTML::Parser. 633 # args: - $aTag: tag name (in lower case). 634 635 sub end { 636 # Get arguments 637 my ($self, $aTag, $aOrigText) = @_; 638 # Add token to array of update tokens 639 $self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_END]{$aTag} = ''; 640 } # end() 641 642 643 #--- HTML::_TokenUpdateParser::parse() ---------------------------------------- 644 # function: Parse token. 645 # args: - $aToken: 'update token' to parse 646 647 sub parse { 648 # Get arguments 649 my ($self, $aString) = @_; 650 # Call ancestor 651 $self->SUPER::parse($aString); 652 } # parse() 653 654 655 #--- HTML::_TokenUpdateParser::start() ---------------------------------------- 656 # function: This function is called every time an opening tag is encountered. 657 # args: - $aTag: tag name (in lower case). 658 # - $aAttr: reference to hash containing all tag attributes (in lower 659 # case). 660 # - $aAttrSeq: reference to array containing all tag attributes (in 661 # lower case) in the original order 662 # - $aOrigText: the original HTML text 663 664 sub start { 665 # Get arguments 666 my ($self, $aTag, $aAttr, $aAttrSeq, $aOrigText) = @_; 667 # Does token exist in array? 668 if (! HTML::TocUpdator::_doesTagExistInArray( 669 $aTag, $aAttr, $self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_START] 670 )) { 671 # No, token doesn't exist in array; 672 # Add token to array of update tokens 673 push( 674 @{$self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_START]}, 675 [$aTag, $aAttr] 676 ); 677 } 678 } # start() 679 680 681 #--- HTML::_TokenUpdateParser::text() ----------------------------------------- 682 # function: This function is called every time plain text is encountered. 683 # args: - @_: array containing data. 684 685 sub text { 686 # Get arguments 687 my ($self, $aText) = @_; 688 # Add token to array of update tokens 689 $self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_TEXT]{$aText} = ''; 690 } # text() 691 692 693 1; 694