2 * CDE - Common Desktop Environment
4 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
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)
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
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with these libraries and programs; if not, write
20 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
21 * Floor, Boston, MA 02110-1301 USA
23 /* $XConsortium: parseParam.C /main/1 1996/07/29 17:09:31 cde-hp $ */
24 // Copyright (c) 1994 James Clark
25 // See the file COPYING for copying permission.
32 #include "ParserMessages.h"
33 #include "MessageArg.h"
34 #include "TokenMessageArg.h"
39 namespace SP_NAMESPACE {
42 Boolean Parser::parseParam(const AllowedParams &allow,
43 unsigned declInputLevel,
47 Token token = getToken(allow.mainMode());
49 case tokenUnrecognized:
50 if (reportNonSgmlCharacter())
53 message(ParserMessages::markupDeclarationCharacter,
54 StringMessageArg(currentToken()),
55 AllowedParamsMessageArg(allow, syntaxPointer()));
59 if (inputLevel() <= declInputLevel) {
60 message(ParserMessages::declarationLevel);
64 currentMarkup()->addEntityEnd();
68 if (!parseComment(comMode))
73 paramInvalidToken(tokenDso, allow);
77 currentMarkup()->addDelim(Syntax::dDSO);
78 parm.type = Param::dso;
82 currentMarkup()->addDelim(Syntax::dGRPO);
83 switch (allow.group()) {
85 paramInvalidToken(tokenGrpo, allow);
87 case Param::modelGroup:
90 if (!parseModelGroup(1, declInputLevel, group, grpsufMode))
92 parm.type = Param::modelGroup;
93 parm.modelGroupPtr = group;
96 case Param::nameGroup:
97 if (!parseNameGroup(declInputLevel, parm))
100 case Param::nameTokenGroup:
101 if (!parseNameTokenGroup(declInputLevel, parm))
107 parm.type = allow.group();
111 parm.type = allow.literal();
112 parm.lita = token == tokenLita;
113 switch (allow.literal()) {
115 paramInvalidToken(token, allow);
117 case Param::minimumLiteral:
118 if (!parseMinimumLiteral(parm.lita, parm.literalText))
121 case Param::attributeValueLiteral:
122 if (!parseAttributeValueLiteral(parm.lita, parm.literalText))
125 case Param::tokenizedAttributeValueLiteral:
126 if (!parseTokenizedAttributeValueLiteral(parm.lita, parm.literalText))
129 case Param::systemIdentifier:
130 if (!parseSystemIdentifier(parm.lita, parm.literalText))
133 case Param::paramLiteral:
134 if (!parseParameterLiteral(parm.lita, parm.literalText))
139 currentMarkup()->addLiteral(parm.literalText);
143 paramInvalidToken(tokenMdc, allow);
146 if (inputLevel() > declInputLevel)
147 message(ParserMessages::parameterEntityNotEnded);
149 currentMarkup()->addDelim(Syntax::dMDC);
150 parm.type = Param::mdc;
153 parm.type = Param::minus;
155 currentMarkup()->addDelim(Syntax::dMINUS);
158 if (!allow.exclusions()) {
159 paramInvalidToken(tokenMinusGrpo, allow);
162 if (currentMarkup()) {
163 currentMarkup()->addDelim(Syntax::dMINUS);
164 currentMarkup()->addDelim(Syntax::dGRPO);
166 parm.type = Param::exclusions;
167 return parseElementNameGroup(declInputLevel, parm);
169 parm.type = Param::pero;
171 currentMarkup()->addDelim(Syntax::dPERO);
175 message(ParserMessages::peroGrpoProlog);
177 case tokenPeroNameStart:
179 ConstPtr<Entity> entity;
180 Ptr<EntityOrigin> origin;
181 if (!parseEntityReference(1, token == tokenPeroGrpo, entity, origin))
183 if (!entity.isNull())
184 entity->declReference(*this, origin);
188 if (!allow.inclusions()) {
189 paramInvalidToken(tokenPlusGrpo, allow);
192 if (currentMarkup()) {
193 currentMarkup()->addDelim(Syntax::dPLUS);
194 currentMarkup()->addDelim(Syntax::dGRPO);
196 parm.type = Param::inclusions;
197 return parseElementNameGroup(declInputLevel, parm);
200 paramInvalidToken(tokenRni, allow);
203 return parseIndicatedReservedName(allow, parm);
206 currentMarkup()->addS(currentChar());
209 switch (allow.nameStart()) {
211 paramInvalidToken(tokenNameStart, allow);
213 case Param::reservedName:
214 return parseReservedName(allow, parm);
216 extendNameToken(syntax().namelen(), ParserMessages::nameLength);
217 parm.type = Param::name;
218 getCurrentToken(syntax().generalSubstTable(), parm.token);
220 currentMarkup()->addName(currentInput());
222 case Param::entityName:
223 extendNameToken(syntax().namelen(), ParserMessages::nameLength);
224 parm.type = Param::entityName;
225 getCurrentToken(syntax().entitySubstTable(), parm.token);
227 currentMarkup()->addName(currentInput());
229 case Param::paramEntityName:
230 extendNameToken(syntax().penamelen(),
231 ParserMessages::parameterEntityNameLength);
232 parm.type = Param::paramEntityName;
233 getCurrentToken(syntax().entitySubstTable(), parm.token);
235 currentMarkup()->addName(currentInput());
237 case Param::attributeValue:
238 return parseAttributeValueParam(parm);
242 switch (allow.digit()) {
244 paramInvalidToken(tokenDigit, allow);
247 extendNumber(syntax().namelen(), ParserMessages::numberLength);
248 parm.type = Param::number;
249 getCurrentToken(parm.token);
251 currentMarkup()->addNumber(currentInput());
253 case Param::attributeValue:
254 return parseAttributeValueParam(parm);
257 case tokenLcUcNmchar:
258 switch (allow.nmchar()) {
260 paramInvalidToken(tokenLcUcNmchar, allow);
262 case Param::attributeValue:
263 return parseAttributeValueParam(parm);
272 void Parser::paramInvalidToken(Token token, const AllowedParams &allow)
274 message(ParserMessages::paramInvalidToken,
275 TokenMessageArg(token, allow.mainMode(),
276 syntaxPointer(), sdPointer()),
277 AllowedParamsMessageArg(allow, syntaxPointer()));
280 Boolean Parser::parseGroupToken(const AllowedGroupTokens &allow,
281 unsigned nestingLevel,
282 unsigned declInputLevel,
283 unsigned groupInputLevel,
287 Token token = getToken(grpMode);
290 if (inputLevel() <= groupInputLevel) {
291 message(ParserMessages::groupLevel);
292 if (inputLevel() <= declInputLevel)
296 message(ParserMessages::groupEntityEnd);
298 currentMarkup()->addEntityEnd();
303 message(ParserMessages::peroGrpoProlog);
305 case tokenPeroNameStart:
307 ConstPtr<Entity> entity;
308 Ptr<EntityOrigin> origin;
309 if (!parseEntityReference(1, token == tokenPeroGrpo, entity, origin))
311 if (!entity.isNull())
312 entity->declReference(*this, origin);
315 case tokenUnrecognized:
316 if (reportNonSgmlCharacter())
319 message(ParserMessages::groupCharacter,
320 StringMessageArg(currentToken()),
321 AllowedGroupTokensMessageArg(allow, syntaxPointer()));
325 if (!allow.groupToken(GroupToken::dataTagGroup)) {
326 groupTokenInvalidToken(tokenDtgo, allow);
330 message(ParserMessages::datatagNotImplemented);
332 currentMarkup()->addDelim(Syntax::dDTGO);
333 return parseDataTagGroup(nestingLevel + 1, declInputLevel, gt);
336 currentMarkup()->addDelim(Syntax::dGRPO);
337 switch (allow.group()) {
338 case GroupToken::modelGroup:
340 ModelGroup *modelGroup;
341 if (!parseModelGroup(nestingLevel + 1, declInputLevel, modelGroup,
344 gt.model = modelGroup;
345 gt.type = GroupToken::modelGroup;
348 case GroupToken::dataTagTemplateGroup:
349 return parseDataTagTemplateGroup(nestingLevel + 1, declInputLevel, gt);
351 groupTokenInvalidToken(tokenGrpo, allow);
356 if (!allow.groupToken(GroupToken::pcdata)) {
357 groupTokenInvalidToken(tokenRni, allow);
360 Syntax::ReservedName rn;
361 if (!getIndicatedReservedName(&rn))
363 if (rn != Syntax::rPCDATA) {
364 StringC token(syntax().delimGeneral(Syntax::dRNI));
365 token += syntax().reservedName(Syntax::rPCDATA);
366 message(ParserMessages::invalidToken, StringMessageArg(token));
369 gt.type = GroupToken::pcdata;
370 gt.contentToken = new PcdataToken;
373 if (currentMarkup()) {
375 currentMarkup()->addS(currentInput());
379 switch (allow.nameStart()) {
380 case GroupToken::elementToken:
382 extendNameToken(syntax().namelen(), ParserMessages::nameLength);
383 gt.type = GroupToken::elementToken;
384 StringC &buffer = nameBuffer();
385 getCurrentToken(syntax().generalSubstTable(), buffer);
387 currentMarkup()->addName(currentInput());
388 const ElementType *e = lookupCreateElement(buffer);
389 ContentToken::OccurrenceIndicator oi
390 = getOccurrenceIndicator(grpMode);
391 gt.contentToken = new ElementToken(e, oi);
394 case GroupToken::name:
395 case GroupToken::nameToken:
396 extendNameToken(syntax().namelen(),
397 token == GroupToken::name
398 ? ParserMessages::nameLength
399 : ParserMessages::nameTokenLength);
400 getCurrentToken(syntax().generalSubstTable(), gt.token);
401 gt.type = allow.nameStart();
402 if (currentMarkup()) {
403 if (gt.type == GroupToken::nameToken)
404 currentMarkup()->addNameToken(currentInput());
406 currentMarkup()->addName(currentInput());
410 groupTokenInvalidToken(tokenNameStart, allow);
414 case tokenLcUcNmchar:
415 if (!allow.groupToken(GroupToken::nameToken)) {
416 groupTokenInvalidToken(token, allow);
419 extendNameToken(syntax().namelen(), ParserMessages::nameTokenLength);
420 getCurrentToken(syntax().generalSubstTable(), gt.token);
421 gt.type = GroupToken::nameToken;
423 currentMarkup()->addNameToken(currentInput());
427 // parameter literal in data tag pattern
428 if (!allow.groupToken(GroupToken::dataTagLiteral)) {
429 groupTokenInvalidToken(token, allow);
432 if (!parseDataTagParameterLiteral(token == tokenLita, gt.text))
434 gt.type = GroupToken::dataTagLiteral;
436 currentMarkup()->addLiteral(gt.text);
446 groupTokenInvalidToken(token, allow);
453 void Parser::groupTokenInvalidToken(Token token, const AllowedGroupTokens &allow)
455 message(ParserMessages::groupTokenInvalidToken,
456 TokenMessageArg(token, grpMode, syntaxPointer(), sdPointer()),
457 AllowedGroupTokensMessageArg(allow, syntaxPointer()));
461 Boolean Parser::parseGroupConnector(const AllowedGroupConnectors &allow,
462 unsigned declInputLevel,
463 unsigned groupInputLevel,
467 Token token = getToken(grpMode);
470 if (inputLevel() <= groupInputLevel) {
471 message(ParserMessages::groupLevel);
472 if (inputLevel() <= declInputLevel)
476 currentMarkup()->addEntityEnd();
480 if (currentMarkup()) {
482 currentMarkup()->addS(currentInput());
487 message(ParserMessages::peroGrpoProlog);
491 case tokenPeroNameStart:
492 message(ParserMessages::groupEntityReference);
494 case tokenUnrecognized:
495 if (reportNonSgmlCharacter())
498 message(ParserMessages::groupCharacter,
499 StringMessageArg(currentToken()),
500 AllowedGroupConnectorsMessageArg(allow, syntaxPointer()));
504 if (!allow.groupConnector(GroupConnector::andGC)) {
505 groupConnectorInvalidToken(tokenAnd, allow);
508 gc.type = GroupConnector::andGC;
510 currentMarkup()->addDelim(Syntax::dAND);
513 if (!allow.groupConnector(GroupConnector::seqGC)) {
514 groupConnectorInvalidToken(tokenSeq, allow);
517 gc.type = GroupConnector::seqGC;
519 currentMarkup()->addDelim(Syntax::dSEQ);
522 if (!allow.groupConnector(GroupConnector::orGC)) {
523 groupConnectorInvalidToken(tokenOr, allow);
526 gc.type = GroupConnector::orGC;
528 currentMarkup()->addDelim(Syntax::dOR);
531 if (!allow.groupConnector(GroupConnector::dtgcGC)) {
532 groupConnectorInvalidToken(tokenDtgc, allow);
535 gc.type = GroupConnector::dtgcGC;
536 if (inputLevel() > groupInputLevel)
537 message(ParserMessages::groupParameterEntityNotEnded);
539 currentMarkup()->addDelim(Syntax::dDTGC);
542 if (!allow.groupConnector(GroupConnector::grpcGC)) {
543 groupConnectorInvalidToken(tokenGrpc, allow);
546 gc.type = GroupConnector::grpcGC;
547 if (inputLevel() > groupInputLevel)
548 message(ParserMessages::groupParameterEntityNotEnded);
550 currentMarkup()->addDelim(Syntax::dGRPC);
553 groupConnectorInvalidToken(token, allow);
559 void Parser::groupConnectorInvalidToken(Token token,
560 const AllowedGroupConnectors &allow)
562 message(ParserMessages::connectorInvalidToken,
563 TokenMessageArg(token, grpMode, syntaxPointer(), sdPointer()),
564 AllowedGroupConnectorsMessageArg(allow, syntaxPointer()));
567 Boolean Parser::parseElementNameGroup(unsigned declInputLevel, Param &parm)
569 if (!parseNameGroup(declInputLevel, parm))
571 parm.elementVector.resize(parm.nameTokenVector.size());
572 for (size_t i = 0; i < parm.nameTokenVector.size(); i++)
573 parm.elementVector[i] = lookupCreateElement(parm.nameTokenVector[i].name);
577 Boolean Parser::parseEntityReferenceNameGroup(Boolean &ignore)
580 if (!parseNameGroup(inputLevel(), parm))
583 for (size_t i = 0; i < parm.nameTokenVector.size(); i++) {
584 const Lpd *lpd = lookupLpd(parm.nameTokenVector[i].name).pointer();
585 if (lpd && lpd->active()) {
595 Boolean Parser::parseTagNameGroup(Boolean &active)
598 if (!parseNameGroup(inputLevel(), parm))
604 Boolean Parser::parseNameGroup(unsigned declInputLevel, Param &parm)
606 static AllowedGroupTokens allowName(GroupToken::name);
607 return parseGroup(allowName, declInputLevel, parm);
610 Boolean Parser::parseNameTokenGroup(unsigned declInputLevel, Param &parm)
612 static AllowedGroupTokens allowNameToken(GroupToken::nameToken);
613 return parseGroup(allowNameToken, declInputLevel, parm);
617 Boolean groupContains(const Vector<NameToken> &vec, const StringC &str)
619 for (size_t i = 0; i < vec.size(); i++)
620 if (vec[i].name == str)
625 Boolean Parser::parseGroup(const AllowedGroupTokens &allowToken,
626 unsigned declInputLevel,
629 unsigned groupInputLevel = inputLevel();
631 Vector<NameToken> &vec = parm.nameTokenVector;
633 GroupConnector::Type connector = GroupConnector::grpcGC;
636 if (!parseGroupToken(allowToken, 0, declInputLevel, groupInputLevel, gt))
638 if (groupContains(vec, gt.token)) {
640 message(ParserMessages::duplicateGroupToken,
641 StringMessageArg(gt.token));
644 vec.resize(vec.size() + 1);
645 gt.token.swap(vec.back().name);
646 getCurrentToken(vec.back().origName);
647 vec.back().loc = currentLocation();
650 static AllowedGroupConnectors allowAnyConnectorGrpc(GroupConnector::orGC,
651 GroupConnector::andGC,
652 GroupConnector::seqGC,
653 GroupConnector::grpcGC);
655 if (!parseGroupConnector(allowAnyConnectorGrpc, declInputLevel,
656 groupInputLevel, gc))
658 if (gc.type == GroupConnector::grpcGC)
660 if (connector == GroupConnector::grpcGC)
662 else if (gc.type != connector) {
663 if (options().warnShould)
664 message(ParserMessages::mixedConnectors);
668 if (nDuplicates + vec.size() > syntax().grpcnt())
669 message(ParserMessages::groupCount, NumberMessageArg(syntax().grpcnt()));
673 Boolean Parser::parseDataTagGroup(unsigned nestingLevel,
674 unsigned declInputLevel, GroupToken &result)
676 if (nestingLevel - 1 == syntax().grplvl())
677 message(ParserMessages::grplvl, NumberMessageArg(syntax().grplvl()));
678 unsigned groupInputLevel = inputLevel();
680 static AllowedGroupTokens allowName(GroupToken::name);
681 if (!parseGroupToken(allowName, nestingLevel, declInputLevel,
682 groupInputLevel, gt))
684 const ElementType *element = lookupCreateElement(gt.token);
686 static AllowedGroupConnectors allowSeq(GroupConnector::seqGC);
687 if (!parseGroupConnector(allowSeq, declInputLevel, groupInputLevel, gc))
689 static AllowedGroupTokens
690 allowDataTagLiteralDataTagTemplateGroup(GroupToken::dataTagLiteral,
691 GroupToken::dataTagTemplateGroup);
692 if (!parseGroupToken(allowDataTagLiteralDataTagTemplateGroup,
698 Vector<Text> templates;
699 if (gt.type == GroupToken::dataTagTemplateGroup)
700 gt.textVector.swap(templates);
703 gt.text.swap(templates[0]);
705 static AllowedGroupConnectors allowSeqDtgc(GroupConnector::seqGC,
706 GroupConnector::dtgcGC);
707 if (!parseGroupConnector(allowSeqDtgc, declInputLevel, groupInputLevel, gc))
709 NCVector<Owner<ContentToken> > vec(2);
710 vec[1] = new PcdataToken;
711 if (gc.type != GroupConnector::dtgcGC) {
712 static AllowedGroupTokens allowDataTagLiteral(GroupToken::dataTagLiteral);
713 if (!parseGroupToken(allowDataTagLiteral,
719 vec[0] = new DataTagElementToken(element, templates, gt.text);
720 static AllowedGroupConnectors allowDtgc(GroupConnector::dtgcGC);
721 if (!parseGroupConnector(allowDtgc, declInputLevel, groupInputLevel, gc))
725 vec[0] = new DataTagElementToken(element, templates);
726 ContentToken::OccurrenceIndicator oi = getOccurrenceIndicator(grpMode);
727 result.contentToken = new DataTagGroup(vec, oi);
728 result.type = GroupToken::dataTagGroup;
732 Boolean Parser::parseDataTagTemplateGroup(unsigned nestingLevel,
733 unsigned declInputLevel,
736 if (nestingLevel - 1 == syntax().grplvl())
737 message(ParserMessages::grplvl, NumberMessageArg(syntax().grplvl()));
738 unsigned groupInputLevel = inputLevel();
739 Vector<Text> &vec = result.textVector;
742 static AllowedGroupTokens allowDataTagLiteral(GroupToken::dataTagLiteral);
743 if (!parseGroupToken(allowDataTagLiteral,
749 if (vec.size() == syntax().grpcnt())
750 message(ParserMessages::groupCount, NumberMessageArg(syntax().grpcnt()));
751 vec.resize(vec.size() + 1);
752 gt.text.swap(vec.back());
753 static AllowedGroupConnectors allowOrGrpc(GroupConnector::orGC,
754 GroupConnector::grpcGC);
756 if (!parseGroupConnector(allowOrGrpc, declInputLevel, groupInputLevel, gc))
758 if (gc.type == GroupConnector::grpcGC)
764 Boolean Parser::parseModelGroup(unsigned nestingLevel, unsigned declInputLevel,
765 ModelGroup *&group, Mode oiMode)
767 if (nestingLevel - 1 == syntax().grplvl())
768 message(ParserMessages::grplvl, NumberMessageArg(syntax().grplvl()));
769 unsigned groupInputLevel = inputLevel();
771 NCVector<Owner<ContentToken> > tokenVector;
772 GroupConnector::Type connector = GroupConnector::grpcGC;
774 static AllowedGroupTokens allowContentToken(GroupToken::pcdata,
775 GroupToken::dataTagGroup,
776 GroupToken::elementToken,
777 GroupToken::modelGroup);
778 static AllowedGroupConnectors allowAnyConnectorGrpc(GroupConnector::orGC,
779 GroupConnector::andGC,
780 GroupConnector::seqGC,
781 GroupConnector::grpcGC);
783 static AllowedGroupConnectors allowOrGrpc(GroupConnector::orGC,
784 GroupConnector::grpcGC);
785 static AllowedGroupConnectors allowAndGrpc(GroupConnector::andGC,
786 GroupConnector::grpcGC);
787 static AllowedGroupConnectors allowSeqGrpc(GroupConnector::seqGC,
788 GroupConnector::grpcGC);
789 const AllowedGroupConnectors *connectorp = &allowAnyConnectorGrpc;
793 if (!parseGroupToken(allowContentToken, nestingLevel, declInputLevel,
794 groupInputLevel, gt))
796 ContentToken *contentToken;
797 if (gt.type == GroupToken::modelGroup)
798 contentToken = gt.model.extract();
800 contentToken = gt.contentToken.extract();
801 if (tokenVector.size() == syntax().grpcnt())
802 message(ParserMessages::groupCount, NumberMessageArg(syntax().grpcnt()));
803 tokenVector.resize(tokenVector.size() + 1);
804 tokenVector.back() = contentToken;
805 if (!parseGroupConnector(*connectorp, declInputLevel, groupInputLevel, gc))
807 if (tokenVector.size() == 1) {
810 case GroupConnector::orGC:
811 connectorp = &allowOrGrpc;
813 case GroupConnector::seqGC:
814 connectorp = &allowSeqGrpc;
816 case GroupConnector::andGC:
817 connectorp = &allowAndGrpc;
823 } while (gc.type != GroupConnector::grpcGC);
824 ContentToken::OccurrenceIndicator oi
825 = getOccurrenceIndicator(oiMode);
827 case GroupConnector::orGC:
828 group = new OrModelGroup(tokenVector, oi);
830 case GroupConnector::grpcGC:
831 case GroupConnector::seqGC:
832 group = new SeqModelGroup(tokenVector, oi);
834 case GroupConnector::andGC:
835 group = new AndModelGroup(tokenVector, oi);
843 ContentToken::OccurrenceIndicator
844 Parser::getOccurrenceIndicator(Mode oiMode)
846 Token token = getToken(oiMode);
850 currentMarkup()->addDelim(Syntax::dPLUS);
851 return ContentToken::plus;
854 currentMarkup()->addDelim(Syntax::dOPT);
855 return ContentToken::opt;
858 currentMarkup()->addDelim(Syntax::dREP);
859 return ContentToken::rep;
861 currentInput()->ungetToken();
862 return ContentToken::none;
866 Boolean Parser::parseMinimumLiteral(Boolean lita, Text &text)
868 return parseLiteral(lita ? mlitaMode : mlitMode, mlitMode,
869 Syntax::referenceQuantity(Syntax::qLITLEN),
870 ParserMessages::minimumLiteralLength,
871 literalSingleSpace|literalMinimumData
872 |(eventsWanted().wantPrologMarkup()
878 Boolean Parser::parseSystemIdentifier(Boolean lita, Text &text)
880 return parseLiteral(lita ? slitaMode : slitMode, slitMode, syntax().litlen(),
881 ParserMessages::systemIdentifierLength,
882 (eventsWanted().wantPrologMarkup()
887 Boolean Parser::parseParameterLiteral(Boolean lita, Text &text)
889 return parseLiteral(lita ? plitaMode : plitMode, pliteMode, syntax().litlen(),
890 ParserMessages::parameterLiteralLength,
891 (eventsWanted().wantPrologMarkup()
897 Boolean Parser::parseDataTagParameterLiteral(Boolean lita, Text &text)
899 return parseLiteral(lita ? plitaMode : plitMode, pliteMode,
901 ParserMessages::dataTagPatternLiteralLength,
903 | (eventsWanted().wantPrologMarkup()
909 Boolean Parser::parseIndicatedReservedName(const AllowedParams &allow,
912 Syntax::ReservedName rn;
913 if (!getIndicatedReservedName(&rn))
915 if (!allow.reservedName(rn)) {
916 message(ParserMessages::invalidReservedName,
917 StringMessageArg(currentToken()));
920 parm.type = Param::indicatedReservedName + rn;
924 Boolean Parser::parseReservedName(const AllowedParams &allow,
927 Syntax::ReservedName rn;
928 if (!getReservedName(&rn))
930 if (!allow.reservedName(rn)) {
931 message(ParserMessages::invalidReservedName,
932 StringMessageArg(syntax().reservedName(rn)));
935 parm.type = Param::reservedName + rn;
940 Boolean Parser::parseAttributeValueParam(Param &parm)
942 extendNameToken(syntax().litlen() > syntax().normsep()
943 ? syntax().litlen() - syntax().normsep()
945 ParserMessages::attributeValueLength);
946 parm.type = Param::attributeValue;
948 text.addChars(currentInput()->currentTokenStart(),
949 currentInput()->currentTokenLength(),
951 text.swap(parm.literalText);
953 currentMarkup()->addAttributeValue(currentInput());
957 Boolean Parser::getIndicatedReservedName(Syntax::ReservedName *result)
960 currentMarkup()->addDelim(Syntax::dRNI);
961 InputSource *in = currentInput();
963 if (!syntax().isNameStartCharacter(in->tokenChar(messenger()))) {
964 message(ParserMessages::rniNameStart);
967 extendNameToken(syntax().namelen(), ParserMessages::nameLength);
968 StringC &buffer = nameBuffer();
969 getCurrentToken(syntax().generalSubstTable(), buffer);
970 if (!syntax().lookupReservedName(buffer, result)) {
972 if (!options().errorAfdr && buffer == sd().execToDoc("ALL"))
973 *result = Syntax::rANY;
975 message(ParserMessages::noSuchReservedName, StringMessageArg(buffer));
980 currentMarkup()->addReservedName(*result, currentInput());
984 Boolean Parser::getReservedName(Syntax::ReservedName *result)
986 extendNameToken(syntax().namelen(), ParserMessages::nameLength);
987 StringC &buffer = nameBuffer();
988 getCurrentToken(syntax().generalSubstTable(), buffer);
989 if (!syntax().lookupReservedName(buffer, result)) {
990 message(ParserMessages::noSuchReservedName, StringMessageArg(buffer));
994 currentMarkup()->addReservedName(*result, currentInput());