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