cde/programs/nsgmls/ParserState.h

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $XConsortium: ParserState.h /main/1 1996/07/29 17:01:25 cde-hp $ */
  24 // Copyright (c) 1994 James Clark
  25 // See the file COPYING for copying permission.
  26
  27 #ifndef ParserState_INCLUDED
  28 #define ParserState_INCLUDED 1
  29 #ifdef __GNUG__
  30 #pragma interface
  31 #endif
  32
  33 #include <stddef.h>
  34 #include <signal.h>
  35 #include "Allocator.h"
  36 #include "Attribute.h"
  37 #include "Boolean.h"
  38 #include "Vector.h"
  39 #include "StringC.h"
  40 #include "Dtd.h"
  41 #include "Entity.h"
  42 #include "EntityCatalog.h"
  43 #include "EntityManager.h"
  44 #include "Event.h"
  45 #include "EventQueue.h"
  46 #include "Id.h"
  47 #include "InputSource.h"
  48 #include "IList.h"
  49 #include "IQueue.h"
  50 #include "Location.h"
  51 #include "Message.h"
  52 #include "Mode.h"
  53 #include "OpenElement.h"
  54 #include "OutputState.h"
  55 #include "ParserOptions.h"
  56 #include "Ptr.h"
  57 #include "Recognizer.h"
  58 #include "Sd.h"
  59 #include "Syntax.h"
  60 #include "NCVector.h"
  61 #include "Owner.h"
  62 #include "Lpd.h"
  63 #include "LpdEntityRef.h"
  64 #include "Markup.h"
  65 #include "ContentState.h"
  66
  67 #ifdef SP_NAMESPACE
  68 namespace SP_NAMESPACE {
  69 #endif
  70
  71 class ParserState : public ContentState, public AttributeContext {
  72 public:
  73   enum Phase {
  74     noPhase,
  75     initPhase,
  76     prologPhase,
  77     declSubsetPhase,
  78     instanceStartPhase,
  79     contentPhase
  80     };
  81   ParserState(const Ptr<EntityManager> &,
  82               const ParserOptions &,
  83               unsigned subdocLevel,
  84               Phase finalPhase);
  85   void setHandler(EventHandler *, SP_CONST SP_VOLATILE sig_atomic_t *cancelPtr);
  86   void unsetHandler();
  87   Boolean inInstance() const;
  88   Boolean hadDtd() const;
  89   void allDone();
  90   void startDtd(const StringC &);
  91   void endDtd();
  92   void startInstance();
  93   unsigned subdocLevel() const;
  94   Boolean haveDefLpd() const;
  95   Dtd &defDtd();
  96   const Ptr<Dtd> &defDtdPointer() const;
  97   Boolean haveCurrentDtd() const;
  98   const Dtd &currentDtd() const;
  99   const ConstPtr<Dtd> &currentDtdPointer() const;
 100   void startLpd(Ptr<Lpd> &lpd);
 101   void endLpd();
 102   Lpd &defLpd();
 103   Ptr<Lpd> &defLpdPointer();
 104   Ptr<ComplexLpd> defComplexLpdPointer();
 105   size_t nActiveLink() const;
 106   const Lpd &activeLpd(size_t i) const;
 107   ComplexLpd &defComplexLpd();
 108   Ptr<Dtd> lookupDtd(const StringC &name);
 109   Ptr<Dtd> baseDtd();
 110   void activateLinkType(const StringC &);
 111   void allLinkTypesActivated();
 112   void setResultAttributeSpecMode();
 113   void clearResultAttributeSpecMode();
 114   Boolean haveApplicableDtd() const;
 115   Boolean hadLpd() const;
 116   Boolean pass2() const;
 117   void setPass2Start();
 118   Boolean maybeStartPass2();
 119   void checkEntityStability();
 120   void noteReferencedEntity(const ConstPtr<Entity> &entity,
 121                             Boolean, Boolean);
 122   ConstPtr<Lpd> lookupLpd(const StringC &name) const;
 123   Boolean shouldActivateLink(const StringC &) const;
 124   Char currentChar() const;
 125   const Location &currentLocation() const;
 126   InputSource *currentInput() const;
 127   EntityManager &entityManager() const;
 128   Ptr<EntityManager> entityManagerPtr() const;
 129   const EntityCatalog &entityCatalog() const;
 130   ConstPtr<EntityCatalog> entityCatalogPtr() const;
 131   void setEntityCatalog(const ConstPtr<EntityCatalog> &);
 132   void setSyntax(ConstPtr<Syntax>);
 133   void setSyntaxes(ConstPtr<Syntax>, ConstPtr<Syntax>);
 134   void setSd(ConstPtr<Sd>);
 135   const Syntax &syntax() const;
 136   const Syntax &instanceSyntax() const;
 137   const ConstPtr<Syntax> &syntaxPointer() const;
 138   const ConstPtr<Syntax> &prologSyntaxPointer() const;
 139   const ConstPtr<Syntax> &instanceSyntaxPointer() const;
 140   const Sd &sd() const;
 141   const ConstPtr<Sd> &sdPointer() const;
 142   void setPhase(Phase phase);
 143   Phase phase() const;
 144   Phase finalPhase() const;
 145   Mode currentMode() const;
 146   void setRecognizer(Mode, ConstPtr<Recognizer>);
 147   void setNormalMap(const XcharMap<PackedBoolean> &);
 148   const XcharMap<PackedBoolean> &normalMap() const;
 149   Xchar getChar();
 150   void skipChar();
 151   Token getToken(Mode mode);
 152   StringC currentToken() const;
 153   void getCurrentToken(StringC &) const;
 154   void getCurrentToken(const SubstTable<Char> *, StringC &) const;
 155   unsigned inputLevel() const;
 156   unsigned specialParseInputLevel() const;
 157   unsigned markedSectionLevel() const;
 158   unsigned markedSectionSpecialLevel() const;
 159   const Location &currentMarkedSectionStartLocation() const;
 160   Boolean entityIsOpen(const Entity *) const;
 161   void popInputStack();
 162   void pushInput(InputSource *);
 163   Boolean referenceDsEntity(const Location &);
 164   void setDsEntity(const ConstPtr<Entity> &);
 165   Boolean eventQueueEmpty() const;
 166   Event *eventQueueGet();
 167   EventHandler &eventHandler();
 168   void pushElement(OpenElement *);
 169   OpenElement *popSaveElement();
 170   void popElement();
 171   void pcdataRecover();
 172   Boolean pcdataRecovering() const;
 173   ConstPtr<Entity> lookupEntity(Boolean isParameter,
 174                                 const StringC &name,
 175                                 const Location &,
 176                                 Boolean referenced);
 177   Boolean appendCurrentRank(StringC &, const RankStem *) const;
 178   void setCurrentRank(const RankStem *, const StringC &);
 179   void startMarkedSection(const Location &);
 180   void startSpecialMarkedSection(Mode, const Location &);
 181   void endMarkedSection();
 182   void queueRe(const Location &);
 183   void noteMarkup();
 184   void noteData();
 185   void noteRs();
 186   void noteStartElement(Boolean included);
 187   void noteEndElement(Boolean included);
 188   // size of objects allocated with this must not exceed
 189   // sizeof(StartElementEvent)
 190   Allocator &eventAllocator();
 191   // size of objects allocated with this must not exceed
 192   // sizeof(OpenElement)
 193   Allocator &internalAllocator();
 194   AttributeList *allocAttributeList(const ConstPtr<AttributeDefinitionList> &,
 195                                     unsigned i);
 196
 197   static void freeEvent(void *);
 198   Boolean wantMarkup() const;
 199   const EventsWanted &eventsWanted() const;
 200   StringC &nameBuffer();
 201   typedef NamedTableIter<Id> IdTableIter;
 202   IdTableIter idTableIter();
 203   const ParserOptions &options() const;
 204   void keepMessages();
 205   void releaseKeptMessages();
 206   void discardKeptMessages();
 207   Messenger &messenger();
 208
 209   Markup *currentMarkup();
 210   const Location &markupLocation() const;
 211   Markup *startMarkup(Boolean, const Location &);
 212   void inheritActiveLinkTypes(const ParserState &parent);
 213   Boolean cancelled() const;
 214
 215   // AFDR extensions
 216   void setHadAfdrDecl();
 217   Boolean hadAfdrDecl() const;
 218
 219   // Implementation of AttributeContext.
 220   Boolean defineId(const StringC &, const Location &, Location &);
 221   void noteIdref(const StringC &, const Location &);
 222   void noteCurrentAttribute(size_t, AttributeValue *);
 223   ConstPtr<AttributeValue> getCurrentAttribute(size_t) const;
 224   ConstPtr<Entity> getAttributeEntity(const StringC &,
 225                                       const Location &);
 226   ConstPtr<Notation> getAttributeNotation(const StringC &,
 227                                           const Location &);
 228   const Syntax &attributeSyntax() const;
 229
 230 private:
 231   ParserState(const ParserState &); // undefined
 232   void operator=(const ParserState &); // undefined
 233   void dispatchMessage(Message &);
 234   void dispatchMessage(const Message &);
 235   void initMessage(Message &);
 236   void queueMessage(MessageEvent *);
 237   Id *lookupCreateId(const StringC &);
 238
 239   ParserOptions options_;
 240   EventHandler *handler_;
 241   Pass1EventHandler pass1Handler_;
 242   Boolean allowPass2_;
 243   Offset pass2StartOffset_;
 244   Boolean hadPass2Start_;
 245   EventQueue eventQueue_;
 246   OutputState outputState_;
 247   ConstPtr<Syntax> prologSyntax_;
 248   ConstPtr<Syntax> instanceSyntax_;
 249   ConstPtr<Sd> sd_;
 250   unsigned subdocLevel_;
 251   Ptr<EntityManager> entityManager_;
 252   ConstPtr<EntityCatalog> entityCatalog_;
 253   Phase phase_;
 254   Phase finalPhase_;
 255   Boolean inInstance_;
 256   Ptr<Dtd> defDtd_;
 257   Ptr<Lpd> defLpd_;
 258   Vector<ConstPtr<Lpd> > allLpd_;
 259   Vector<ConstPtr<Lpd> > lpd_; // active LPDs
 260   Vector<StringC> activeLinkTypes_;
 261   Boolean activeLinkTypesSubsted_;
 262   Boolean hadLpd_;
 263   Boolean resultAttributeSpecMode_;
 264   Boolean pass2_;
 265   typedef OwnerTable<LpdEntityRef, LpdEntityRef, LpdEntityRef, LpdEntityRef>
 266     LpdEntityRefSet;
 267   typedef OwnerTableIter<LpdEntityRef, LpdEntityRef, LpdEntityRef, LpdEntityRef>
 268     LpdEntityRefSetIter;
 269   LpdEntityRefSet lpdEntityRefs_;
 270   // external entity to be referenced at the end of the declaration subset
 271   ConstPtr<Entity> dsEntity_;
 272   Allocator eventAllocator_;
 273   Allocator internalAllocator_;
 274   NCVector<Owner<AttributeList> > attributeLists_;
 275   StringC nameBuffer_;
 276   Boolean keepingMessages_;
 277   IQueue<MessageEvent> keptMessages_;
 278   Mode currentMode_;
 279   Boolean pcdataRecovering_;
 280   // if in a special parse (cdata, rcdata, ignore), the input level
 281   // at which the special parse started.
 282   unsigned specialParseInputLevel_;
 283   Mode specialParseMode_;
 284   unsigned markedSectionLevel_;
 285   unsigned markedSectionSpecialLevel_;
 286   Vector<Location> markedSectionStartLocation_;
 287   ConstPtr<Recognizer> recognizers_[nModes];
 288   XcharMap<PackedBoolean> normalMap_;
 289   unsigned inputLevel_;
 290   IList<InputSource> inputStack_;
 291   ConstPtr<Dtd> currentDtd_;
 292   Vector<Ptr<Dtd> > dtd_;
 293   Ptr<Dtd> pass1Dtd_;
 294   ConstPtr<Syntax> syntax_;
 295   Vector<StringC> currentRank_;
 296   NamedTable<Id> idTable_;
 297   NamedResourceTable<Entity> instanceDefaultedEntityTable_;
 298   Vector<ConstPtr<AttributeValue> > currentAttributes_;
 299   Markup *currentMarkup_;
 300   Markup markup_;
 301   Location markupLocation_;
 302   Boolean hadAfdrDecl_;
 303   SP_CONST SP_VOLATILE sig_atomic_t *cancelPtr_;
 304   static sig_atomic_t dummyCancel_;
 305   static const Location nullLocation_;
 306 };
 307
 308 inline
 309 Messenger &ParserState::messenger()
 310 {
 311   return *this;
 312 }
 313
 314 inline
 315 Boolean ParserState::wantMarkup() const
 316 {
 317   return (inInstance_
 318           ? options_.eventsWanted.wantInstanceMarkup()
 319           : options_.eventsWanted.wantPrologMarkup());
 320 }
 321
 322 inline
 323 const EventsWanted &ParserState::eventsWanted() const
 324 {
 325   return options_.eventsWanted;
 326 }
 327
 328 inline
 329 InputSource *ParserState::currentInput() const
 330 {
 331   return inputStack_.head();
 332 }
 333
 334 inline
 335 const Location &ParserState::currentLocation() const
 336 {
 337   InputSource *in = currentInput();
 338   return in ? in->currentLocation() : nullLocation_;
 339 }
 340
 341 inline
 342 Boolean ParserState::pcdataRecovering() const
 343 {
 344   return pcdataRecovering_;
 345 }
 346
 347 inline
 348 unsigned ParserState::inputLevel() const
 349 {
 350   return inputLevel_;
 351 }
 352
 353 inline
 354 unsigned ParserState::specialParseInputLevel() const
 355 {
 356   return specialParseInputLevel_;
 357 }
 358
 359 inline
 360 unsigned ParserState::markedSectionLevel() const
 361 {
 362   return markedSectionLevel_;
 363 }
 364
 365 inline
 366 unsigned ParserState::markedSectionSpecialLevel() const
 367 {
 368   return markedSectionSpecialLevel_;
 369 }
 370
 371 inline
 372 const Location &ParserState::currentMarkedSectionStartLocation() const
 373 {
 374   return markedSectionStartLocation_.back();
 375 }
 376
 377 inline
 378 Char ParserState::currentChar() const
 379 {
 380   return currentInput()->currentTokenStart()[0];
 381 }
 382
 383 inline
 384 StringC ParserState::currentToken() const
 385 {
 386   return StringC(currentInput()->currentTokenStart(),
 387                  currentInput()->currentTokenLength());
 388 }
 389
 390 inline
 391 void ParserState::getCurrentToken(StringC &str) const
 392 {
 393   InputSource *in = currentInput();
 394   str.assign(in->currentTokenStart(), in->currentTokenLength());
 395 }
 396
 397 inline
 398 void ParserState::setRecognizer(Mode mode, ConstPtr<Recognizer> p)
 399 {
 400   recognizers_[mode] = p;
 401 }
 402
 403 inline
 404 void ParserState::setNormalMap(const XcharMap<PackedBoolean> &map)
 405 {
 406   normalMap_ = map;
 407 }
 408
 409 inline
 410 const XcharMap<PackedBoolean> &ParserState::normalMap() const
 411 {
 412   return normalMap_;
 413 }
 414
 415 inline
 416 Boolean ParserState::haveDefLpd() const
 417 {
 418   return !defLpd_.isNull();
 419 }
 420
 421 inline
 422 Boolean ParserState::haveCurrentDtd() const
 423 {
 424   return !currentDtd_.isNull();
 425 }
 426
 427 inline
 428 Dtd &ParserState::defDtd()
 429 {
 430   return *defDtd_;
 431 }
 432
 433 inline
 434 const Dtd &ParserState::currentDtd() const
 435 {
 436   return *currentDtd_;
 437 }
 438
 439 inline
 440 const Ptr<Dtd> &ParserState::defDtdPointer() const
 441 {
 442   return defDtd_;
 443 }
 444
 445 inline
 446 const ConstPtr<Dtd> &ParserState::currentDtdPointer() const
 447 {
 448   return currentDtd_;
 449 }
 450
 451 inline
 452 Boolean ParserState::inInstance() const
 453 {
 454   return inInstance_;
 455 }
 456
 457 inline
 458 const Syntax &ParserState::syntax() const
 459 {
 460   return *syntax_;
 461 }
 462
 463 inline
 464 const Syntax &ParserState::instanceSyntax() const
 465 {
 466   return *instanceSyntax_;
 467 }
 468
 469 inline
 470 const ConstPtr<Syntax> &ParserState::syntaxPointer() const
 471 {
 472   return syntax_;
 473 }
 474
 475 inline
 476 const ConstPtr<Syntax> &ParserState::instanceSyntaxPointer() const
 477 {
 478   return instanceSyntax_;
 479 }
 480
 481 inline
 482 const ConstPtr<Syntax> &ParserState::prologSyntaxPointer() const
 483 {
 484   return prologSyntax_;
 485 }
 486
 487 inline
 488 const Sd &ParserState::sd() const
 489 {
 490   return *sd_;
 491 }
 492
 493 inline
 494 const ConstPtr<Sd> &ParserState::sdPointer() const
 495 {
 496   return sd_;
 497 }
 498
 499 inline
 500 void ParserState::setPhase(Phase phase)
 501 {
 502   phase_ = phase;
 503 }
 504
 505 inline
 506 Mode ParserState::currentMode() const
 507 {
 508   return currentMode_;
 509 }
 510
 511 inline
 512 Xchar ParserState::getChar()
 513 {
 514   return inputStack_.head()->get(messenger());
 515 }
 516
 517 inline
 518 void ParserState::skipChar()
 519 {
 520   (void)getChar();
 521 }
 522
 523 inline
 524 Token ParserState::getToken(Mode mode)
 525 {
 526   return recognizers_[mode]->recognize(inputStack_.head(), messenger());
 527 }
 528
 529 inline
 530 Boolean ParserState::hadDtd() const
 531 {
 532   return dtd_.size() > 0;
 533 }
 534
 535 inline
 536 Boolean ParserState::eventQueueEmpty() const
 537 {
 538   return eventQueue_.empty();
 539 }
 540
 541 inline
 542 Event *ParserState::eventQueueGet()
 543 {
 544   return eventQueue_.get();
 545 }
 546
 547 inline
 548 ParserState::Phase ParserState::phase() const
 549 {
 550   return phase_;
 551 }
 552
 553 inline
 554 ParserState::Phase ParserState::finalPhase() const
 555 {
 556   return finalPhase_;
 557 }
 558
 559 inline
 560 EntityManager &ParserState::entityManager() const
 561 {
 562   return *entityManager_;
 563 }
 564
 565 inline
 566 Ptr<EntityManager> ParserState::entityManagerPtr() const
 567 {
 568   return entityManager_;
 569 }
 570
 571 inline
 572 const EntityCatalog &ParserState::entityCatalog() const
 573 {
 574   return *entityCatalog_;
 575 }
 576
 577 inline
 578 ConstPtr<EntityCatalog> ParserState::entityCatalogPtr() const
 579 {
 580   return entityCatalog_;
 581 }
 582
 583 inline
 584 void ParserState::setEntityCatalog(const ConstPtr<EntityCatalog> &catalog)
 585 {
 586   entityCatalog_ = catalog;
 587 }
 588
 589 inline
 590 void ParserState::setDsEntity(const ConstPtr<Entity> &entity)
 591 {
 592   dsEntity_ = entity;
 593 }
 594
 595 inline
 596 Allocator &ParserState::eventAllocator()
 597 {
 598   return eventAllocator_;
 599 }
 600
 601 inline
 602 Allocator &ParserState::internalAllocator()
 603 {
 604   return internalAllocator_;
 605 }
 606
 607 inline
 608 StringC &ParserState::nameBuffer()
 609 {
 610   return nameBuffer_;
 611 }
 612
 613 inline
 614 void ParserState::setHandler(EventHandler *handler,
 615                              SP_CONST SP_VOLATILE sig_atomic_t *cancelPtr)
 616 {
 617   handler_ = handler;
 618   cancelPtr_ = cancelPtr ? cancelPtr : &dummyCancel_;
 619 }
 620
 621 inline
 622 void ParserState::unsetHandler()
 623 {
 624   handler_ = &eventQueue_;
 625   cancelPtr_ = &dummyCancel_;
 626 }
 627
 628 inline
 629 void ParserState::queueRe(const Location &location)
 630 {
 631   outputState_.handleRe(*handler_, eventAllocator_, options_.eventsWanted,
 632                         syntax().standardFunction(Syntax::fRE),
 633                         location);
 634 }
 635
 636 inline
 637 void ParserState::noteMarkup()
 638 {
 639   if (inInstance_)
 640     outputState_.noteMarkup(*handler_, eventAllocator_, options_.eventsWanted);
 641 }
 642
 643 inline
 644 void ParserState::noteRs()
 645 {
 646   outputState_.noteRs(*handler_, eventAllocator_, options_.eventsWanted);
 647 }
 648
 649 inline
 650 void ParserState::noteStartElement(Boolean included)
 651 {
 652   outputState_.noteStartElement(included, *handler_, eventAllocator_,
 653                                 options_.eventsWanted);
 654 }
 655
 656 inline
 657 void ParserState::noteEndElement(Boolean included)
 658 {
 659   outputState_.noteEndElement(included, *handler_, eventAllocator_,
 660                               options_.eventsWanted);
 661 }
 662
 663 inline
 664 void ParserState::noteData()
 665 {
 666   outputState_.noteData(*handler_, eventAllocator_, options_.eventsWanted);
 667 }
 668
 669 inline
 670 unsigned ParserState::subdocLevel() const
 671 {
 672   return subdocLevel_;
 673 }
 674
 675 inline
 676 EventHandler &ParserState::eventHandler()
 677 {
 678   return *handler_;
 679 }
 680
 681 inline
 682 ParserState::IdTableIter ParserState::idTableIter()
 683 {
 684   // Avoid use of typedef to work around MSVC 2.0 bug.
 685   return NamedTableIter<Id>(idTable_);
 686 }
 687
 688 inline
 689 const ParserOptions &ParserState::options() const
 690 {
 691   return options_;
 692 }
 693
 694 inline
 695 void ParserState::keepMessages()
 696 {
 697   keepingMessages_ = 1;
 698 }
 699
 700 inline
 701 Boolean ParserState::haveApplicableDtd() const
 702 {
 703   return !currentDtd_.isNull();
 704 }
 705
 706 inline
 707 Boolean ParserState::hadLpd() const
 708 {
 709   return hadLpd_;
 710 }
 711
 712 inline
 713 Boolean ParserState::pass2() const
 714 {
 715   return pass2_;
 716 }
 717
 718 inline
 719 size_t ParserState::nActiveLink() const
 720 {
 721   return lpd_.size();
 722 }
 723
 724 inline
 725 const Lpd &ParserState::activeLpd(size_t i) const
 726 {
 727   return *lpd_[i];
 728 }
 729
 730 inline
 731 Lpd &ParserState::defLpd()
 732 {
 733   return *defLpd_;
 734 }
 735
 736 inline
 737 Ptr<Lpd> &ParserState::defLpdPointer()
 738 {
 739   return defLpd_;
 740 }
 741
 742 inline
 743 Ptr<ComplexLpd> ParserState::defComplexLpdPointer()
 744 {
 745   return (ComplexLpd *)defLpd_.pointer();
 746 }
 747
 748 inline
 749 ComplexLpd &ParserState::defComplexLpd()
 750 {
 751   return (ComplexLpd &)defLpd();
 752 }
 753
 754 inline
 755 Ptr<Dtd> ParserState::baseDtd()
 756 {
 757   if (dtd_.size() > 0)
 758     return dtd_[0];
 759   else
 760     return Ptr<Dtd>();
 761 }
 762
 763 inline
 764 void ParserState::setResultAttributeSpecMode()
 765 {
 766   resultAttributeSpecMode_ = 1;
 767 }
 768
 769 inline
 770 void ParserState::clearResultAttributeSpecMode()
 771 {
 772   resultAttributeSpecMode_ = 0;
 773 }
 774
 775 inline
 776 Markup *ParserState::currentMarkup()
 777 {
 778   return currentMarkup_;
 779 }
 780
 781 inline
 782 const Location &ParserState::markupLocation() const
 783 {
 784   return markupLocation_;
 785 }
 786
 787 inline
 788 Markup *ParserState::startMarkup(Boolean storing, const Location &loc)
 789 {
 790   markupLocation_ = loc;
 791   if (storing) {
 792     markup_.clear();
 793     return currentMarkup_ = &markup_;
 794   }
 795   else
 796     return currentMarkup_ = 0;
 797 }
 798
 799 inline
 800 Boolean ParserState::cancelled() const
 801 {
 802   return *cancelPtr_ != 0;
 803 }
 804
 805 inline
 806 void ParserState::setHadAfdrDecl()
 807 {
 808   hadAfdrDecl_ = 1;
 809 }
 810
 811 inline
 812 Boolean ParserState::hadAfdrDecl() const
 813 {
 814   return hadAfdrDecl_;
 815 }
 816
 817 #ifdef SP_NAMESPACE
 818 }
 819 #endif
 820
 821 #endif /* not ParserState_INCLUDED */