1442 lines
40 KiB
C++
1442 lines
40 KiB
C++
// Copyright (c) 1994 James Clark, 1999 Matthias Clasen
|
|
// See the file COPYING for copying permission.
|
|
|
|
#include "splib.h"
|
|
#include "Parser.h"
|
|
#include "ParserMessages.h"
|
|
#include "MessageArg.h"
|
|
#include "TokenMessageArg.h"
|
|
#include "token.h"
|
|
#include "macros.h"
|
|
|
|
#ifdef SP_NAMESPACE
|
|
namespace SP_NAMESPACE {
|
|
#endif
|
|
|
|
void Parser::doInstanceStart()
|
|
{
|
|
if (cancelled()) {
|
|
allDone();
|
|
return;
|
|
}
|
|
// FIXME check here that we have a valid dtd
|
|
compileInstanceModes();
|
|
setPhase(contentPhase);
|
|
Token token = getToken(currentMode());
|
|
switch (token) {
|
|
case tokenEe:
|
|
case tokenStagoNameStart:
|
|
case tokenStagoTagc:
|
|
case tokenStagoGrpo:
|
|
case tokenEtagoNameStart:
|
|
case tokenEtagoTagc:
|
|
case tokenEtagoGrpo:
|
|
break;
|
|
default:
|
|
if (sd().omittag()) {
|
|
unsigned startImpliedCount = 0;
|
|
unsigned attributeListIndex = 0;
|
|
IList<Undo> undoList;
|
|
IList<Event> eventList;
|
|
if (!tryImplyTag(currentLocation(),
|
|
startImpliedCount,
|
|
attributeListIndex,
|
|
undoList,
|
|
eventList))
|
|
CANNOT_HAPPEN();
|
|
queueElementEvents(eventList);
|
|
}
|
|
else
|
|
message(ParserMessages::instanceStartOmittag);
|
|
}
|
|
currentInput()->ungetToken();
|
|
}
|
|
|
|
void Parser::endInstance()
|
|
{
|
|
// Do checking before popping entity stack so that there's a
|
|
// current location for error messages.
|
|
endAllElements();
|
|
while (markedSectionLevel() > 0) {
|
|
message(ParserMessages::unclosedMarkedSection,
|
|
currentMarkedSectionStartLocation());
|
|
endMarkedSection();
|
|
}
|
|
checkIdrefs();
|
|
popInputStack();
|
|
allDone();
|
|
}
|
|
|
|
void Parser::checkIdrefs()
|
|
{
|
|
IdTableIter iter(idTableIter());
|
|
Id *id;
|
|
while ((id = iter.next()) != 0) {
|
|
for (size_t i = 0; i < id->pendingRefs().size(); i++) {
|
|
Messenger::setNextLocation(id->pendingRefs()[i]);
|
|
message(ParserMessages::missingId, StringMessageArg(id->name()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void Parser::doContent()
|
|
{
|
|
do {
|
|
if (cancelled()) {
|
|
allDone();
|
|
return;
|
|
}
|
|
Token token = getToken(currentMode());
|
|
switch (token) {
|
|
case tokenEe:
|
|
if (inputLevel() == 1) {
|
|
endInstance();
|
|
return;
|
|
}
|
|
if (inputLevel() == specialParseInputLevel()) {
|
|
// FIXME have separate messages for each type of special parse
|
|
// perhaps force end of marked section or element
|
|
message(ParserMessages::specialParseEntityEnd);
|
|
}
|
|
if (eventsWanted().wantInstanceMarkup())
|
|
eventHandler().entityEnd(new (eventAllocator())
|
|
EntityEndEvent(currentLocation()));
|
|
if (afterDocumentElement())
|
|
message(ParserMessages::afterDocumentElementEntityEnd);
|
|
if (sd().integrallyStored()
|
|
&& tagLevel()
|
|
&& currentElement().index() != currentInputElementIndex())
|
|
message(ParserMessages::contentAsyncEntityRef);
|
|
popInputStack();
|
|
break;
|
|
case tokenCroDigit:
|
|
case tokenHcroHexDigit:
|
|
{
|
|
if (afterDocumentElement())
|
|
message(ParserMessages::characterReferenceAfterDocumentElement);
|
|
Char ch;
|
|
Location loc;
|
|
if (parseNumericCharRef(token == tokenHcroHexDigit, ch, loc)) {
|
|
acceptPcdata(loc);
|
|
noteData();
|
|
Boolean isSgmlChar;
|
|
if (!translateNumericCharRef(ch, isSgmlChar))
|
|
break;
|
|
if (!isSgmlChar) {
|
|
eventHandler().nonSgmlChar(new (eventAllocator())
|
|
NonSgmlCharEvent(ch, loc));
|
|
break;
|
|
}
|
|
eventHandler().data(new (eventAllocator())
|
|
ImmediateDataEvent(Event::characterData,
|
|
&ch, 1, loc, 1));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case tokenCroNameStart:
|
|
if (afterDocumentElement())
|
|
message(ParserMessages::characterReferenceAfterDocumentElement);
|
|
parseNamedCharRef();
|
|
break;
|
|
case tokenEroGrpo:
|
|
case tokenEroNameStart:
|
|
{
|
|
if (afterDocumentElement())
|
|
message(ParserMessages::entityReferenceAfterDocumentElement);
|
|
ConstPtr<Entity> entity;
|
|
Ptr<EntityOrigin> origin;
|
|
if (parseEntityReference(0, token == tokenEroGrpo, entity, origin)) {
|
|
if (!entity.isNull()) {
|
|
if (entity->isCharacterData())
|
|
acceptPcdata(Location(origin.pointer(), 0));
|
|
if (inputLevel() == specialParseInputLevel())
|
|
entity->rcdataReference(*this, origin);
|
|
else
|
|
entity->contentReference(*this, origin);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case tokenEtagoNameStart:
|
|
acceptEndTag(parseEndTag());
|
|
break;
|
|
case tokenEtagoTagc:
|
|
parseEmptyEndTag();
|
|
break;
|
|
case tokenEtagoGrpo:
|
|
parseGroupEndTag();
|
|
break;
|
|
case tokenMdoNameStart:
|
|
if (startMarkup(eventsWanted().wantInstanceMarkup(), currentLocation()))
|
|
currentMarkup()->addDelim(Syntax::dMDO);
|
|
Syntax::ReservedName name;
|
|
Boolean result;
|
|
unsigned startLevel;
|
|
startLevel = inputLevel();
|
|
if (parseDeclarationName(&name)) {
|
|
switch (name) {
|
|
case Syntax::rUSEMAP:
|
|
if (afterDocumentElement())
|
|
message(ParserMessages::declarationAfterDocumentElement,
|
|
StringMessageArg(syntax().reservedName(name)));
|
|
result = parseUsemapDecl();
|
|
break;
|
|
case Syntax::rUSELINK:
|
|
if (afterDocumentElement())
|
|
message(ParserMessages::declarationAfterDocumentElement,
|
|
StringMessageArg(syntax().reservedName(name)));
|
|
result = parseUselinkDecl();
|
|
break;
|
|
case Syntax::rDOCTYPE:
|
|
case Syntax::rLINKTYPE:
|
|
case Syntax::rELEMENT:
|
|
case Syntax::rATTLIST:
|
|
case Syntax::rENTITY:
|
|
case Syntax::rNOTATION:
|
|
case Syntax::rSHORTREF:
|
|
case Syntax::rLINK:
|
|
case Syntax::rIDLINK:
|
|
message(ParserMessages::instanceDeclaration,
|
|
StringMessageArg(syntax().reservedName(name)));
|
|
result = 0;
|
|
break;
|
|
default:
|
|
message(ParserMessages::noSuchDeclarationType,
|
|
StringMessageArg(syntax().reservedName(name)));
|
|
result = 0;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
result = 0;
|
|
if (!result)
|
|
skipDeclaration(startLevel);
|
|
noteMarkup();
|
|
break;
|
|
case tokenMdoMdc:
|
|
// empty comment
|
|
emptyCommentDecl();
|
|
noteMarkup();
|
|
break;
|
|
case tokenMdoCom:
|
|
parseCommentDecl();
|
|
noteMarkup();
|
|
break;
|
|
case tokenMdoDso:
|
|
if (afterDocumentElement())
|
|
message(ParserMessages::markedSectionAfterDocumentElement);
|
|
parseMarkedSectionDeclStart();
|
|
noteMarkup();
|
|
break;
|
|
case tokenMscMdc:
|
|
handleMarkedSectionEnd();
|
|
noteMarkup();
|
|
break;
|
|
case tokenNet:
|
|
parseNullEndTag();
|
|
break;
|
|
case tokenPio:
|
|
parseProcessingInstruction();
|
|
break;
|
|
case tokenStagoNameStart:
|
|
parseStartTag();
|
|
break;
|
|
case tokenStagoTagc:
|
|
parseEmptyStartTag();
|
|
break;
|
|
case tokenStagoGrpo:
|
|
parseGroupStartTag();
|
|
break;
|
|
case tokenRe:
|
|
acceptPcdata(currentLocation());
|
|
queueRe(currentLocation());
|
|
break;
|
|
case tokenRs:
|
|
acceptPcdata(currentLocation());
|
|
noteRs();
|
|
if (eventsWanted().wantInstanceMarkup())
|
|
eventHandler().ignoredRs(new (eventAllocator())
|
|
IgnoredRsEvent(currentChar(),
|
|
currentLocation()));
|
|
break;
|
|
case tokenS:
|
|
extendContentS();
|
|
if (eventsWanted().wantInstanceMarkup())
|
|
eventHandler().sSep(new (eventAllocator())
|
|
SSepEvent(currentInput()->currentTokenStart(),
|
|
currentInput()->currentTokenLength(),
|
|
currentLocation(),
|
|
0));
|
|
break;
|
|
case tokenIgnoredChar:
|
|
extendData();
|
|
if (eventsWanted().wantMarkedSections())
|
|
eventHandler().ignoredChars(new (eventAllocator())
|
|
IgnoredCharsEvent(currentInput()->currentTokenStart(),
|
|
currentInput()->currentTokenLength(),
|
|
currentLocation(),
|
|
0));
|
|
break;
|
|
case tokenUnrecognized:
|
|
reportNonSgmlCharacter();
|
|
parsePcdata();
|
|
break;
|
|
case tokenCharDelim:
|
|
message(ParserMessages::dataCharDelim,
|
|
StringMessageArg(StringC(currentInput()->currentTokenStart(),
|
|
currentInput()->currentTokenLength())));
|
|
// fall through
|
|
case tokenChar:
|
|
parsePcdata();
|
|
break;
|
|
default:
|
|
ASSERT(token >= tokenFirstShortref);
|
|
handleShortref(token - tokenFirstShortref);
|
|
break;
|
|
}
|
|
} while (eventQueueEmpty());
|
|
}
|
|
|
|
void Parser::skipDeclaration(unsigned startLevel)
|
|
{
|
|
const unsigned skipMax = 250;
|
|
unsigned skipCount = 0;
|
|
for (;;) {
|
|
Token token = getToken(mdMode);
|
|
if (inputLevel() == startLevel)
|
|
skipCount++;
|
|
switch (token) {
|
|
case tokenUnrecognized:
|
|
(void)getChar();
|
|
break;
|
|
case tokenEe:
|
|
if (inputLevel() <= startLevel)
|
|
return;
|
|
popInputStack();
|
|
return;
|
|
case tokenMdc:
|
|
if (inputLevel() == startLevel)
|
|
return;
|
|
break;
|
|
case tokenS:
|
|
if (inputLevel() == startLevel && skipCount >= skipMax
|
|
&& currentChar() == syntax().standardFunction(Syntax::fRE))
|
|
return;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Parser::handleShortref(int index)
|
|
{
|
|
const ConstPtr<Entity> &entity
|
|
= currentElement().map()->entity(index);
|
|
if (!entity.isNull()) {
|
|
Owner<Markup> markupPtr;
|
|
if (eventsWanted().wantInstanceMarkup()) {
|
|
markupPtr = new Markup;
|
|
markupPtr->addShortref(currentInput());
|
|
}
|
|
Ptr<EntityOrigin> origin
|
|
= EntityOrigin::make(internalAllocator(),
|
|
entity,
|
|
currentLocation(),
|
|
currentInput()->currentTokenLength(),
|
|
markupPtr);
|
|
entity->contentReference(*this, origin);
|
|
return;
|
|
}
|
|
InputSource *in = currentInput();
|
|
size_t length = in->currentTokenLength();
|
|
const Char *s = in->currentTokenStart();
|
|
size_t i = 0;
|
|
if (currentMode() == econMode || currentMode() == econnetMode) {
|
|
// FIXME do this in advance (what about B sequence?)
|
|
for (i = 0; i < length && syntax().isS(s[i]); i++)
|
|
;
|
|
if (i > 0 && eventsWanted().wantInstanceMarkup())
|
|
eventHandler().sSep(new (eventAllocator())
|
|
SSepEvent(s, i, currentLocation(), 0));
|
|
}
|
|
if (i < length) {
|
|
Location location(currentLocation());
|
|
location += i;
|
|
s += i;
|
|
length -= i;
|
|
acceptPcdata(location);
|
|
if (sd().keeprsre()) {
|
|
noteData();
|
|
eventHandler().data(new (eventAllocator())
|
|
ImmediateDataEvent(Event::characterData, s, length,
|
|
location, 0));
|
|
return;
|
|
}
|
|
// FIXME speed this up
|
|
for (; length > 0; location += 1, length--, s++) {
|
|
if (*s == syntax().standardFunction(Syntax::fRS)) {
|
|
noteRs();
|
|
if (eventsWanted().wantInstanceMarkup())
|
|
eventHandler().ignoredRs(new (eventAllocator())
|
|
IgnoredRsEvent(*s, location));
|
|
}
|
|
else if (*s == syntax().standardFunction(Syntax::fRE))
|
|
queueRe(location);
|
|
else {
|
|
noteData();
|
|
eventHandler().data(new (eventAllocator())
|
|
ImmediateDataEvent(Event::characterData, s, 1,
|
|
location, 0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Parser::parsePcdata()
|
|
{
|
|
extendData();
|
|
acceptPcdata(currentLocation());
|
|
noteData();
|
|
eventHandler().data(new (eventAllocator())
|
|
ImmediateDataEvent(Event::characterData,
|
|
currentInput()->currentTokenStart(),
|
|
currentInput()->currentTokenLength(),
|
|
currentLocation(),
|
|
0));
|
|
}
|
|
|
|
void Parser::parseStartTag()
|
|
{
|
|
InputSource *in = currentInput();
|
|
Markup *markup = startMarkup(eventsWanted().wantInstanceMarkup(),
|
|
in->currentLocation());
|
|
if (markup)
|
|
markup->addDelim(Syntax::dSTAGO);
|
|
Boolean netEnabling;
|
|
StartElementEvent *event = doParseStartTag(netEnabling);
|
|
acceptStartTag(event->elementType(), event, netEnabling);
|
|
}
|
|
|
|
StartElementEvent *Parser::doParseStartTag(Boolean &netEnabling)
|
|
{
|
|
Markup *markup = currentMarkup();
|
|
InputSource *in = currentInput();
|
|
in->discardInitial();
|
|
extendNameToken(syntax().namelen(), ParserMessages::nameLength);
|
|
if (markup)
|
|
markup->addName(in);
|
|
StringC &name = nameBuffer();
|
|
getCurrentToken(syntax().generalSubstTable(), name);
|
|
ElementType *e = currentDtdNonConst().lookupElementType(name);
|
|
if (sd().rank()) {
|
|
if (!e)
|
|
e = completeRankStem(name);
|
|
else if (e->isRankedElement())
|
|
handleRankedElement(e);
|
|
}
|
|
if (!e)
|
|
e = lookupCreateUndefinedElement(name, currentLocation(), currentDtdNonConst(), (implydefElement() != Sd::implydefElementAnyother));
|
|
AttributeList *attributes = allocAttributeList(e->attributeDef(), 0);
|
|
Token closeToken = getToken(tagMode);
|
|
if (closeToken == tokenTagc) {
|
|
if (name.size() > syntax().taglen())
|
|
checkTaglen(markupLocation().index());
|
|
attributes->finish(*this);
|
|
netEnabling = 0;
|
|
if (markup)
|
|
markup->addDelim(Syntax::dTAGC);
|
|
}
|
|
else {
|
|
in->ungetToken();
|
|
Ptr<AttributeDefinitionList> newAttDef;
|
|
if (parseAttributeSpec(tagMode, *attributes, netEnabling, newAttDef)) {
|
|
// The difference between the indices will be the difference
|
|
// in offsets plus 1 for each named character reference.
|
|
if (in->currentLocation().index() - markupLocation().index()
|
|
> syntax().taglen())
|
|
checkTaglen(markupLocation().index());
|
|
}
|
|
else
|
|
netEnabling = 0;
|
|
if (!newAttDef.isNull()) {
|
|
newAttDef->setIndex(currentDtdNonConst().allocAttributeDefinitionListIndex());
|
|
e->setAttributeDef(newAttDef);
|
|
}
|
|
}
|
|
return new (eventAllocator()) StartElementEvent(e,
|
|
currentDtdPointer(),
|
|
attributes,
|
|
markupLocation(),
|
|
markup);
|
|
}
|
|
|
|
ElementType *Parser::completeRankStem(const StringC &name)
|
|
{
|
|
const RankStem *rankStem = currentDtd().lookupRankStem(name);
|
|
if (rankStem) {
|
|
StringC name(rankStem->name());
|
|
if (!appendCurrentRank(name, rankStem))
|
|
message(ParserMessages::noCurrentRank, StringMessageArg(name));
|
|
else
|
|
return currentDtdNonConst().lookupElementType(name);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void Parser::handleRankedElement(const ElementType *e)
|
|
{
|
|
StringC rankSuffix(e->definition()->rankSuffix());
|
|
const RankStem *rankStem = e->rankedElementRankStem();
|
|
for (size_t i = 0; i < rankStem->nDefinitions(); i++) {
|
|
const ElementDefinition *def = rankStem->definition(i);
|
|
for (size_t j = 0; j < def->nRankStems(); j++)
|
|
setCurrentRank(def->rankStem(j), rankSuffix);
|
|
}
|
|
}
|
|
|
|
void Parser::checkTaglen(Index tagStartIndex)
|
|
{
|
|
const InputSourceOrigin *origin
|
|
= currentLocation().origin()->asInputSourceOrigin();
|
|
ASSERT(origin != 0);
|
|
if (origin->startOffset(currentLocation().index())
|
|
- origin->startOffset(tagStartIndex
|
|
+ syntax().delimGeneral(Syntax::dSTAGO).size())
|
|
> syntax().taglen())
|
|
message(ParserMessages::taglen, NumberMessageArg(syntax().taglen()));
|
|
}
|
|
|
|
void Parser::parseEmptyStartTag()
|
|
{
|
|
if (options().warnEmptyTag)
|
|
message(ParserMessages::emptyStartTag);
|
|
if (!currentDtd().isBase())
|
|
message(ParserMessages::emptyStartTagBaseDtd);
|
|
const ElementType *e = 0;
|
|
if (!sd().omittag())
|
|
e = lastEndedElementType();
|
|
else if (tagLevel() > 0)
|
|
e = currentElement().type();
|
|
if (!e)
|
|
e = currentDtd().documentElementType();
|
|
AttributeList *attributes = allocAttributeList(e->attributeDef(), 0);
|
|
attributes->finish(*this);
|
|
Markup *markup = startMarkup(eventsWanted().wantInstanceMarkup(),
|
|
currentLocation());
|
|
if (markup) {
|
|
markup->addDelim(Syntax::dSTAGO);
|
|
markup->addDelim(Syntax::dTAGC);
|
|
}
|
|
acceptStartTag(e,
|
|
new (eventAllocator())
|
|
StartElementEvent(e,
|
|
currentDtdPointer(),
|
|
attributes,
|
|
markupLocation(),
|
|
markup),
|
|
0);
|
|
}
|
|
|
|
void Parser::parseGroupStartTag()
|
|
{
|
|
InputSource *in = currentInput();
|
|
if (startMarkup(eventsWanted().wantInstanceMarkup(), currentLocation())) {
|
|
currentMarkup()->addDelim(Syntax::dSTAGO);
|
|
currentMarkup()->addDelim(Syntax::dGRPO);
|
|
}
|
|
Boolean active;
|
|
if (!parseTagNameGroup(active, 1))
|
|
return;
|
|
in->startToken();
|
|
// Location startLocation = in->currentLocation();
|
|
Xchar c = in->tokenChar(messenger());
|
|
if (!syntax().isNameStartCharacter(c)) {
|
|
message(ParserMessages::startTagMissingName);
|
|
return;
|
|
}
|
|
if (active) {
|
|
Boolean netEnabling;
|
|
StartElementEvent *event = doParseStartTag(netEnabling);
|
|
if (netEnabling)
|
|
message(ParserMessages::startTagGroupNet);
|
|
acceptStartTag(event->elementType(), event, netEnabling);
|
|
}
|
|
else {
|
|
in->discardInitial();
|
|
|
|
extendNameToken(syntax().namelen(), ParserMessages::nameLength);
|
|
if (currentMarkup())
|
|
currentMarkup()->addName(currentInput());
|
|
skipAttributeSpec();
|
|
if (currentMarkup())
|
|
eventHandler().ignoredMarkup(new (eventAllocator())
|
|
IgnoredMarkupEvent(markupLocation(),
|
|
currentMarkup()));
|
|
noteMarkup();
|
|
}
|
|
}
|
|
|
|
void Parser::parseGroupEndTag()
|
|
{
|
|
InputSource *in = currentInput();
|
|
if (startMarkup(eventsWanted().wantInstanceMarkup(), currentLocation())) {
|
|
currentMarkup()->addDelim(Syntax::dSTAGO);
|
|
currentMarkup()->addDelim(Syntax::dGRPO);
|
|
}
|
|
Boolean active;
|
|
if (!parseTagNameGroup(active, 0))
|
|
return;
|
|
in->startToken();
|
|
// Location startLocation = in->currentLocation();
|
|
Xchar c = in->tokenChar(messenger());
|
|
if (!syntax().isNameStartCharacter(c)) {
|
|
message(ParserMessages::endTagMissingName);
|
|
return;
|
|
}
|
|
if (active)
|
|
acceptEndTag(doParseEndTag());
|
|
else {
|
|
in->discardInitial();
|
|
extendNameToken(syntax().namelen(), ParserMessages::nameLength);
|
|
if (currentMarkup())
|
|
currentMarkup()->addName(currentInput());
|
|
parseEndTagClose();
|
|
if (currentMarkup())
|
|
eventHandler().ignoredMarkup(new (eventAllocator())
|
|
IgnoredMarkupEvent(markupLocation(),
|
|
currentMarkup()));
|
|
noteMarkup();
|
|
}
|
|
}
|
|
|
|
void Parser::acceptPcdata(const Location &startLocation)
|
|
{
|
|
if (currentElement().tryTransitionPcdata())
|
|
return;
|
|
// Need to test here since implying tags may turn off pcdataRecovering.
|
|
if (pcdataRecovering())
|
|
return;
|
|
IList<Undo> undoList;
|
|
IList<Event> eventList;
|
|
unsigned startImpliedCount = 0;
|
|
unsigned attributeListIndex = 0;
|
|
keepMessages();
|
|
while (tryImplyTag(startLocation, startImpliedCount, attributeListIndex,
|
|
undoList, eventList))
|
|
if (currentElement().tryTransitionPcdata()) {
|
|
queueElementEvents(eventList);
|
|
return;
|
|
}
|
|
discardKeptMessages();
|
|
undo(undoList);
|
|
if (validate() || afterDocumentElement())
|
|
message(ParserMessages::pcdataNotAllowed);
|
|
pcdataRecover();
|
|
}
|
|
|
|
void Parser::acceptStartTag(const ElementType *e,
|
|
StartElementEvent *event,
|
|
Boolean netEnabling)
|
|
{
|
|
if (e->definition()->undefined() && (implydefElement() == Sd::implydefElementNo))
|
|
message(ParserMessages::undefinedElement, StringMessageArg(e->name()));
|
|
if (elementIsExcluded(e)) {
|
|
keepMessages();
|
|
if (validate())
|
|
checkExclusion(e);
|
|
}
|
|
else {
|
|
if (currentElement().tryTransition(e)) {
|
|
pushElementCheck(e, event, netEnabling);
|
|
return;
|
|
}
|
|
if (elementIsIncluded(e)) {
|
|
event->setIncluded();
|
|
pushElementCheck(e, event, netEnabling);
|
|
return;
|
|
}
|
|
keepMessages();
|
|
}
|
|
IList<Undo> undoList;
|
|
IList<Event> eventList;
|
|
unsigned startImpliedCount = 0;
|
|
unsigned attributeListIndex = 1;
|
|
while (tryImplyTag(event->location(), startImpliedCount,
|
|
attributeListIndex, undoList, eventList))
|
|
if (tryStartTag(e, event, netEnabling, eventList))
|
|
return;
|
|
discardKeptMessages();
|
|
undo(undoList);
|
|
if (validate() && !e->definition()->undefined())
|
|
handleBadStartTag(e, event, netEnabling);
|
|
else {
|
|
if (validate() ? (implydefElement() != Sd::implydefElementNo) : afterDocumentElement())
|
|
message(ParserMessages::elementNotAllowed, StringMessageArg(e->name()));
|
|
// If element couldn't occur because it was excluded, then
|
|
// do the transition here.
|
|
(void)currentElement().tryTransition(e);
|
|
pushElementCheck(e, event, netEnabling);
|
|
}
|
|
}
|
|
|
|
void Parser::undo(IList<Undo> &undoList)
|
|
{
|
|
while (!undoList.empty()) {
|
|
Undo *p = undoList.get();
|
|
p->undo(this);
|
|
delete p;
|
|
}
|
|
}
|
|
|
|
void Parser::queueElementEvents(IList<Event> &events)
|
|
{
|
|
releaseKeptMessages();
|
|
// FIXME provide IList<T>::reverse function
|
|
// reverse it
|
|
IList<Event> tem;
|
|
while (!events.empty())
|
|
tem.insert(events.get());
|
|
while (!tem.empty()) {
|
|
Event *e = tem.get();
|
|
if (e->type() == Event::startElement) {
|
|
noteStartElement(((StartElementEvent *)e)->included());
|
|
eventHandler().startElement((StartElementEvent *)e);
|
|
}
|
|
else {
|
|
noteEndElement(((EndElementEvent *)e)->included());
|
|
eventHandler().endElement((EndElementEvent *)e);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void Parser::checkExclusion(const ElementType *e)
|
|
{
|
|
const LeafContentToken *token = currentElement().invalidExclusion(e);
|
|
if (token)
|
|
message(ParserMessages::invalidExclusion,
|
|
OrdinalMessageArg(token->typeIndex() + 1),
|
|
StringMessageArg(token->elementType()->name()),
|
|
StringMessageArg(currentElement().type()->name()));
|
|
}
|
|
|
|
Boolean Parser::tryStartTag(const ElementType *e,
|
|
StartElementEvent *event,
|
|
Boolean netEnabling,
|
|
IList<Event> &impliedEvents)
|
|
{
|
|
if (elementIsExcluded(e)) {
|
|
checkExclusion(e);
|
|
return 0;
|
|
}
|
|
if (currentElement().tryTransition(e)) {
|
|
queueElementEvents(impliedEvents);
|
|
pushElementCheck(e, event, netEnabling);
|
|
return 1;
|
|
}
|
|
if (elementIsIncluded(e)) {
|
|
queueElementEvents(impliedEvents);
|
|
event->setIncluded();
|
|
pushElementCheck(e, event, netEnabling);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Boolean Parser::tryImplyTag(const Location &loc,
|
|
unsigned &startImpliedCount,
|
|
unsigned &attributeListIndex,
|
|
IList<Undo> &undo,
|
|
IList<Event> &eventList)
|
|
{
|
|
if (!sd().omittag())
|
|
return 0;
|
|
if (currentElement().isFinished()) {
|
|
if (tagLevel() == 0)
|
|
return 0;
|
|
#if 1
|
|
const ElementDefinition *def = currentElement().type()->definition();
|
|
if (def && !def->canOmitEndTag())
|
|
return 0;
|
|
#endif
|
|
// imply an end tag
|
|
if (startImpliedCount > 0) {
|
|
message(ParserMessages::startTagEmptyElement,
|
|
StringMessageArg(currentElement().type()->name()));
|
|
startImpliedCount--;
|
|
}
|
|
#if 0
|
|
const ElementDefinition *def = currentElement().type()->definition();
|
|
if (def && !def->canOmitEndTag())
|
|
message(ParserMessages::omitEndTagDeclare,
|
|
StringMessageArg(currentElement().type()->name()),
|
|
currentElement().startLocation());
|
|
#endif
|
|
EndElementEvent *event
|
|
= new (eventAllocator()) EndElementEvent(currentElement().type(),
|
|
currentDtdPointer(),
|
|
loc,
|
|
0);
|
|
eventList.insert(event);
|
|
undo.insert(new (internalAllocator()) UndoEndTag(popSaveElement()));
|
|
return 1;
|
|
}
|
|
const LeafContentToken *token = currentElement().impliedStartTag();
|
|
if (!token)
|
|
return 0;
|
|
const ElementType *e = token->elementType();
|
|
if (elementIsExcluded(e))
|
|
message(ParserMessages::requiredElementExcluded,
|
|
OrdinalMessageArg(token->typeIndex() + 1),
|
|
StringMessageArg(e->name()),
|
|
StringMessageArg(currentElement().type()->name()));
|
|
if (tagLevel() != 0)
|
|
undo.insert(new (internalAllocator())
|
|
UndoTransition(currentElement().matchState()));
|
|
currentElement().doRequiredTransition();
|
|
const ElementDefinition *def = e->definition();
|
|
if (def->declaredContent() != ElementDefinition::modelGroup
|
|
&& def->declaredContent() != ElementDefinition::any)
|
|
message(ParserMessages::omitStartTagDeclaredContent,
|
|
StringMessageArg(e->name()));
|
|
if (def->undefined())
|
|
message(ParserMessages::undefinedElement, StringMessageArg(e->name()));
|
|
else if (!def->canOmitStartTag())
|
|
message(ParserMessages::omitStartTagDeclare, StringMessageArg(e->name()));
|
|
AttributeList *attributes
|
|
= allocAttributeList(e->attributeDef(),
|
|
attributeListIndex++);
|
|
// this will give an error if the element has a required attribute
|
|
attributes->finish(*this);
|
|
startImpliedCount++;
|
|
StartElementEvent *event
|
|
= new (eventAllocator()) StartElementEvent(e,
|
|
currentDtdPointer(),
|
|
attributes,
|
|
loc,
|
|
0);
|
|
pushElementCheck(e, event, undo, eventList);
|
|
const int implyCheckLimit = 30; // this is fairly arbitrary
|
|
if (startImpliedCount > implyCheckLimit
|
|
&& !checkImplyLoop(startImpliedCount))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
void Parser::pushElementCheck(const ElementType *e, StartElementEvent *event,
|
|
Boolean netEnabling)
|
|
{
|
|
if (tagLevel() == syntax().taglvl())
|
|
message(ParserMessages::taglvlOpenElements, NumberMessageArg(syntax().taglvl()));
|
|
noteStartElement(event->included());
|
|
if (event->mustOmitEnd()) {
|
|
if (sd().emptyElementNormal()) {
|
|
Boolean included = event->included();
|
|
Location loc(event->location());
|
|
eventHandler().startElement(event);
|
|
endTagEmptyElement(e, netEnabling, included, loc);
|
|
}
|
|
else {
|
|
EndElementEvent *end
|
|
= new (eventAllocator()) EndElementEvent(e,
|
|
currentDtdPointer(),
|
|
event->location(),
|
|
0);
|
|
if (event->included()) {
|
|
end->setIncluded();
|
|
noteEndElement(1);
|
|
}
|
|
else
|
|
noteEndElement(0);
|
|
eventHandler().startElement(event);
|
|
eventHandler().endElement(end);
|
|
}
|
|
}
|
|
else {
|
|
const ShortReferenceMap *map = e->map();
|
|
if (!map)
|
|
map = currentElement().map();
|
|
if (options().warnImmediateRecursion
|
|
&& e == currentElement().type())
|
|
message(ParserMessages::immediateRecursion);
|
|
pushElement(new (internalAllocator()) OpenElement(e,
|
|
netEnabling,
|
|
event->included(),
|
|
map,
|
|
event->location()));
|
|
// Can't access event after it's passed to the event handler.
|
|
eventHandler().startElement(event);
|
|
}
|
|
}
|
|
|
|
void Parser::endTagEmptyElement(const ElementType *e,
|
|
Boolean netEnabling,
|
|
Boolean included,
|
|
const Location &startLoc)
|
|
{
|
|
Token token = getToken(netEnabling ? econnetMode : econMode);
|
|
switch (token) {
|
|
case tokenNet:
|
|
if (netEnabling) {
|
|
Markup *markup = startMarkup(eventsWanted().wantInstanceMarkup(),
|
|
currentLocation());
|
|
if (markup)
|
|
markup->addDelim(Syntax::dNET);
|
|
EndElementEvent *end
|
|
= new (eventAllocator()) EndElementEvent(e,
|
|
currentDtdPointer(),
|
|
currentLocation(),
|
|
markup);
|
|
if (included)
|
|
end->setIncluded();
|
|
eventHandler().endElement(end);
|
|
noteEndElement(included);
|
|
return;
|
|
}
|
|
break;
|
|
case tokenEtagoTagc:
|
|
{
|
|
if (options().warnEmptyTag)
|
|
message(ParserMessages::emptyEndTag);
|
|
Markup *markup = startMarkup(eventsWanted().wantInstanceMarkup(),
|
|
currentLocation());
|
|
if (markup) {
|
|
markup->addDelim(Syntax::dETAGO);
|
|
markup->addDelim(Syntax::dTAGC);
|
|
}
|
|
EndElementEvent *end
|
|
= new (eventAllocator()) EndElementEvent(e,
|
|
currentDtdPointer(),
|
|
currentLocation(),
|
|
markup);
|
|
if (included)
|
|
end->setIncluded();
|
|
eventHandler().endElement(end);
|
|
noteEndElement(included);
|
|
return;
|
|
}
|
|
case tokenEtagoNameStart:
|
|
{
|
|
EndElementEvent *end = parseEndTag();
|
|
if (end->elementType() == e) {
|
|
if (included)
|
|
end->setIncluded();
|
|
eventHandler().endElement(end);
|
|
noteEndElement(included);
|
|
return;
|
|
}
|
|
if (!elementIsOpen(end->elementType())) {
|
|
message(ParserMessages::elementNotOpen,
|
|
StringMessageArg(end->elementType()->name()));
|
|
delete end;
|
|
break;
|
|
}
|
|
implyEmptyElementEnd(e, included, startLoc);
|
|
acceptEndTag(end);
|
|
return;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
implyEmptyElementEnd(e, included, startLoc);
|
|
currentInput()->ungetToken();
|
|
}
|
|
|
|
void Parser::implyEmptyElementEnd(const ElementType *e,
|
|
Boolean included,
|
|
const Location &startLoc)
|
|
{
|
|
if (!sd().omittag())
|
|
message(ParserMessages::omitEndTagOmittag,
|
|
StringMessageArg(e->name()),
|
|
startLoc);
|
|
else {
|
|
const ElementDefinition *def = e->definition();
|
|
if (def && !def->canOmitEndTag())
|
|
message(ParserMessages::omitEndTagDeclare,
|
|
StringMessageArg(e->name()),
|
|
startLoc);
|
|
}
|
|
EndElementEvent *end
|
|
= new (eventAllocator()) EndElementEvent(e,
|
|
currentDtdPointer(),
|
|
currentLocation(),
|
|
0);
|
|
if (included)
|
|
end->setIncluded();
|
|
noteEndElement(included);
|
|
eventHandler().endElement(end);
|
|
}
|
|
|
|
void Parser::pushElementCheck(const ElementType *e, StartElementEvent *event,
|
|
IList<Undo> &undoList,
|
|
IList<Event> &eventList)
|
|
{
|
|
if (tagLevel() == syntax().taglvl())
|
|
message(ParserMessages::taglvlOpenElements, NumberMessageArg(syntax().taglvl()));
|
|
eventList.insert(event);
|
|
if (event->mustOmitEnd()) {
|
|
EndElementEvent *end
|
|
= new (eventAllocator()) EndElementEvent(e,
|
|
currentDtdPointer(),
|
|
event->location(),
|
|
0);
|
|
if (event->included())
|
|
end->setIncluded();
|
|
eventList.insert(end);
|
|
}
|
|
else {
|
|
undoList.insert(new (internalAllocator()) UndoStartTag);
|
|
const ShortReferenceMap *map = e->map();
|
|
if (!map)
|
|
map = currentElement().map();
|
|
pushElement(new (internalAllocator()) OpenElement(e,
|
|
0,
|
|
event->included(),
|
|
map,
|
|
event->location()));
|
|
}
|
|
}
|
|
|
|
EndElementEvent *Parser::parseEndTag()
|
|
{
|
|
Markup *markup = startMarkup(eventsWanted().wantInstanceMarkup(),
|
|
currentLocation());
|
|
if (markup)
|
|
markup->addDelim(Syntax::dETAGO);
|
|
return doParseEndTag();
|
|
}
|
|
|
|
EndElementEvent *Parser::doParseEndTag()
|
|
{
|
|
Markup *markup = currentMarkup();
|
|
currentInput()->discardInitial();
|
|
extendNameToken(syntax().namelen(), ParserMessages::nameLength);
|
|
if (markup)
|
|
markup->addName(currentInput());
|
|
StringC &name = nameBuffer();
|
|
getCurrentToken(syntax().generalSubstTable(), name);
|
|
const ElementType *e = currentDtd().lookupElementType(name);
|
|
if (sd().rank()) {
|
|
if (!e)
|
|
e = completeRankStem(name);
|
|
}
|
|
if (!e)
|
|
e = lookupCreateUndefinedElement(name, currentLocation(), currentDtdNonConst(), (implydefElement() != Sd::implydefElementAnyother));
|
|
parseEndTagClose();
|
|
return new (eventAllocator())
|
|
EndElementEvent(e,
|
|
currentDtdPointer(),
|
|
markupLocation(),
|
|
markup);
|
|
}
|
|
|
|
void Parser::parseEndTagClose()
|
|
{
|
|
for (;;) {
|
|
Token token = getToken(tagMode);
|
|
switch (token) {
|
|
case tokenUnrecognized:
|
|
if (!reportNonSgmlCharacter())
|
|
message(ParserMessages::endTagCharacter, StringMessageArg(currentToken()));
|
|
return;
|
|
case tokenEe:
|
|
message(ParserMessages::endTagEntityEnd);
|
|
return;
|
|
case tokenEtago:
|
|
case tokenStago:
|
|
if (!sd().endTagUnclosed())
|
|
message(ParserMessages::unclosedEndTagShorttag);
|
|
currentInput()->ungetToken();
|
|
return;
|
|
case tokenTagc:
|
|
if (currentMarkup())
|
|
currentMarkup()->addDelim(Syntax::dTAGC);
|
|
return;
|
|
case tokenS:
|
|
if (currentMarkup())
|
|
currentMarkup()->addS(currentChar());
|
|
break;
|
|
default:
|
|
message(ParserMessages::endTagInvalidToken,
|
|
TokenMessageArg(token, tagMode, syntaxPointer(), sdPointer()));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Parser::parseEmptyEndTag()
|
|
{
|
|
if (options().warnEmptyTag)
|
|
message(ParserMessages::emptyEndTag);
|
|
if (!currentDtd().isBase())
|
|
message(ParserMessages::emptyEndTagBaseDtd);
|
|
if (tagLevel() == 0)
|
|
message(ParserMessages::emptyEndTagNoOpenElements);
|
|
else {
|
|
Markup *markup = startMarkup(eventsWanted().wantInstanceMarkup(),
|
|
currentLocation());
|
|
if (markup) {
|
|
markup->addDelim(Syntax::dETAGO);
|
|
markup->addDelim(Syntax::dTAGC);
|
|
}
|
|
acceptEndTag(new (eventAllocator()) EndElementEvent(currentElement().type(),
|
|
currentDtdPointer(),
|
|
currentLocation(),
|
|
markup));
|
|
}
|
|
}
|
|
|
|
void Parser::parseNullEndTag()
|
|
{
|
|
// If a null end tag was recognized, then there must be a net enabling
|
|
// element on the stack.
|
|
for (;;) {
|
|
ASSERT(tagLevel() > 0);
|
|
if (currentElement().netEnabling())
|
|
break;
|
|
if (!currentElement().isFinished() && validate())
|
|
message(ParserMessages::elementNotFinished,
|
|
StringMessageArg(currentElement().type()->name()));
|
|
implyCurrentElementEnd(currentLocation());
|
|
}
|
|
if (!currentElement().isFinished() && validate())
|
|
message(ParserMessages::elementEndTagNotFinished,
|
|
StringMessageArg(currentElement().type()->name()));
|
|
Markup *markup = startMarkup(eventsWanted().wantInstanceMarkup(),
|
|
currentLocation());
|
|
if (markup)
|
|
markup->addDelim(Syntax::dNET);
|
|
acceptEndTag(new (eventAllocator()) EndElementEvent(currentElement().type(),
|
|
currentDtdPointer(),
|
|
currentLocation(),
|
|
markup));
|
|
}
|
|
|
|
void Parser::endAllElements()
|
|
{
|
|
while (tagLevel() > 0) {
|
|
if (!currentElement().isFinished())
|
|
message(ParserMessages::elementNotFinishedDocumentEnd,
|
|
StringMessageArg(currentElement().type()->name()));
|
|
implyCurrentElementEnd(currentLocation());
|
|
}
|
|
if (!currentElement().isFinished() && validate())
|
|
message(ParserMessages::noDocumentElement);
|
|
}
|
|
|
|
void Parser::acceptEndTag(EndElementEvent *event)
|
|
{
|
|
const ElementType *e = event->elementType();
|
|
if (!elementIsOpen(e)) {
|
|
message(ParserMessages::elementNotOpen, StringMessageArg(e->name()));
|
|
delete event;
|
|
return;
|
|
}
|
|
for (;;){
|
|
if (currentElement().type() == e)
|
|
break;
|
|
if (!currentElement().isFinished() && validate())
|
|
message(ParserMessages::elementNotFinished,
|
|
StringMessageArg(currentElement().type()->name()));
|
|
implyCurrentElementEnd(event->location());
|
|
}
|
|
if (!currentElement().isFinished() && validate())
|
|
message(ParserMessages::elementEndTagNotFinished,
|
|
StringMessageArg(currentElement().type()->name()));
|
|
if (currentElement().included())
|
|
event->setIncluded();
|
|
noteEndElement(event->included());
|
|
eventHandler().endElement(event);
|
|
popElement();
|
|
}
|
|
|
|
void Parser::implyCurrentElementEnd(const Location &loc)
|
|
{
|
|
if (!sd().omittag())
|
|
message(ParserMessages::omitEndTagOmittag,
|
|
StringMessageArg(currentElement().type()->name()),
|
|
currentElement().startLocation());
|
|
else {
|
|
const ElementDefinition *def = currentElement().type()->definition();
|
|
if (def && !def->canOmitEndTag())
|
|
message(ParserMessages::omitEndTagDeclare,
|
|
StringMessageArg(currentElement().type()->name()),
|
|
currentElement().startLocation());
|
|
}
|
|
EndElementEvent *event
|
|
= new (eventAllocator()) EndElementEvent(currentElement().type(),
|
|
currentDtdPointer(),
|
|
loc,
|
|
0);
|
|
if (currentElement().included())
|
|
event->setIncluded();
|
|
noteEndElement(event->included());
|
|
eventHandler().endElement(event);
|
|
popElement();
|
|
}
|
|
|
|
void Parser::extendData()
|
|
{
|
|
XcharMap<PackedBoolean> isNormal(normalMap());
|
|
InputSource *in = currentInput();
|
|
size_t length = in->currentTokenLength();
|
|
// This is one of the parser's inner loops, so it needs to be fast.
|
|
while (isNormal[in->tokenCharInBuffer(messenger())])
|
|
length++;
|
|
in->endToken(length);
|
|
}
|
|
|
|
void Parser::extendContentS()
|
|
{
|
|
InputSource *in = currentInput();
|
|
size_t length = in->currentTokenLength();
|
|
XcharMap<PackedBoolean> isNormal(normalMap());
|
|
for (;;) {
|
|
Xchar ch = in->tokenChar(messenger());
|
|
if (!syntax().isS(ch) || !isNormal[ch])
|
|
break;
|
|
length++;
|
|
}
|
|
in->endToken(length);
|
|
}
|
|
|
|
void Parser::handleBadStartTag(const ElementType *e,
|
|
StartElementEvent *event,
|
|
Boolean netEnabling)
|
|
{
|
|
IList<Undo> undoList;
|
|
IList<Event> eventList;
|
|
keepMessages();
|
|
for (;;) {
|
|
Vector<const ElementType *> missing;
|
|
findMissingTag(e, missing);
|
|
if (missing.size() == 1) {
|
|
queueElementEvents(eventList);
|
|
const ElementType *m = missing[0];
|
|
message(ParserMessages::missingElementInferred,
|
|
StringMessageArg(e->name()),
|
|
StringMessageArg(m->name()));
|
|
AttributeList *attributes
|
|
= allocAttributeList(m->attributeDef(), 1);
|
|
// this will give an error if the element has a required attribute
|
|
attributes->finish(*this);
|
|
StartElementEvent *inferEvent
|
|
= new (eventAllocator()) StartElementEvent(m,
|
|
currentDtdPointer(),
|
|
attributes,
|
|
event->location(),
|
|
0);
|
|
if (!currentElement().tryTransition(m))
|
|
inferEvent->setIncluded();
|
|
pushElementCheck(m, inferEvent, 0);
|
|
if (!currentElement().tryTransition(e))
|
|
event->setIncluded();
|
|
pushElementCheck(e, event, netEnabling);
|
|
return;
|
|
}
|
|
if (missing.size() > 0) {
|
|
queueElementEvents(eventList);
|
|
Vector<StringC> missingNames;
|
|
for (size_t i = 0; i < missing.size(); i++)
|
|
missingNames.push_back(missing[i]->name());
|
|
message(ParserMessages::missingElementMultiple,
|
|
StringMessageArg(e->name()),
|
|
StringVectorMessageArg(missingNames));
|
|
pushElementCheck(e, event, netEnabling);
|
|
return;
|
|
}
|
|
if (!sd().omittag()
|
|
|| !currentElement().isFinished()
|
|
|| tagLevel() == 0
|
|
|| !currentElement().type()->definition()->canOmitEndTag())
|
|
break;
|
|
EndElementEvent *endEvent
|
|
= new (eventAllocator()) EndElementEvent(currentElement().type(),
|
|
currentDtdPointer(),
|
|
event->location(),
|
|
0);
|
|
eventList.insert(endEvent);
|
|
undoList.insert(new (internalAllocator()) UndoEndTag(popSaveElement()));
|
|
}
|
|
discardKeptMessages();
|
|
undo(undoList);
|
|
message(ParserMessages::elementNotAllowed, StringMessageArg(e->name()));
|
|
// If element couldn't occur because it was excluded, then
|
|
// do the transition here.
|
|
(void)currentElement().tryTransition(e);
|
|
pushElementCheck(e, event, netEnabling);
|
|
}
|
|
|
|
void Parser::findMissingTag(const ElementType *e,
|
|
Vector<const ElementType *> &v)
|
|
{
|
|
if (!currentElement().currentPosition()) {
|
|
if (!e)
|
|
v.push_back((const ElementType *)0);
|
|
return;
|
|
}
|
|
if (elementIsExcluded(e))
|
|
return;
|
|
size_t newSize = 0;
|
|
currentElement().matchState().possibleTransitions(v);
|
|
// FIXME also get currentInclusions
|
|
for (size_t i = 0; i < v.size(); i++) {
|
|
if (v[i] && !elementIsExcluded(v[i])) {
|
|
Boolean success = 0;
|
|
switch (v[i]->definition()->declaredContent()) {
|
|
case ElementDefinition::modelGroup:
|
|
{
|
|
const CompiledModelGroup *grp
|
|
= v[i]->definition()->compiledModelGroup();
|
|
MatchState state(grp);
|
|
if (!e) {
|
|
if (state.tryTransitionPcdata())
|
|
success = 1;
|
|
}
|
|
else {
|
|
if (state.tryTransition(e))
|
|
success = 1;
|
|
if (!success) {
|
|
for (size_t j = 0; j < v[i]->definition()->nInclusions(); j++)
|
|
if (v[i]->definition()->inclusion(j) == e) {
|
|
success = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (success) {
|
|
for (size_t j = 0; j < v[i]->definition()->nExclusions(); j++)
|
|
if (v[i]->definition()->exclusion(j) == e) {
|
|
success = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#if 0
|
|
case ElementDefinition::any:
|
|
success = 1;
|
|
break;
|
|
#endif
|
|
case ElementDefinition::cdata:
|
|
case ElementDefinition::rcdata:
|
|
if (e == 0)
|
|
success = 1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (success)
|
|
v[newSize++] = v[i];
|
|
}
|
|
}
|
|
v.resize(newSize);
|
|
// Sort them according to the order of their occurrence in the DTD.
|
|
// Do an insertion sort.
|
|
for (size_t i = 1; i < v.size(); i++) {
|
|
const ElementType *tem = v[i];
|
|
size_t j;
|
|
for (j = i; j > 0 && v[j - 1]->index() > tem->index(); j--)
|
|
v[j] = v[j - 1];
|
|
v[j] = tem;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
// This produces messages that are too verbose
|
|
// This doesn't try to be very efficient.
|
|
// 0 for #pcdata
|
|
|
|
void Parser::getAllowedElementTypes(Vector<const ElementType *> &v)
|
|
{
|
|
v.clear();
|
|
// FIXME get a list of all inclusions first
|
|
// getCurrentInclusions(v);
|
|
// x says whether each element of v was excluded
|
|
Vector<PackedBoolean> x(v.size(), 0);
|
|
unsigned startImpliedCount = 0;
|
|
IList<Undo> undoList;
|
|
for (;;) {
|
|
if (currentElement().currentPosition()) {
|
|
// have a model group
|
|
size_t i = v.size();
|
|
currentElement().matchState().possibleTransitions(v);
|
|
x.resize(v.size());
|
|
for (size_t j = i; j < v.size(); j++)
|
|
x[j] = (v[j] && elementIsExcluded(v[j]));
|
|
if (!sd().omittag())
|
|
break;
|
|
// Try to imply a tag
|
|
if (currentElement().isFinished()) {
|
|
if (tagLevel() == 0)
|
|
break;
|
|
if (startImpliedCount)
|
|
break;
|
|
const ElementDefinition *def = currentElement().type()->definition();
|
|
if (def && def->canOmitEndTag())
|
|
undoList.insert(new (internalAllocator())
|
|
UndoEndTag(popSaveElement()));
|
|
else
|
|
break;
|
|
}
|
|
else {
|
|
const LeafContentToken *token = currentElement().impliedStartTag();
|
|
if (!token)
|
|
break;
|
|
const ElementType *e = token->elementType();
|
|
if (elementIsExcluded(e))
|
|
break;
|
|
const ElementDefinition *def = e->definition();
|
|
if (!def
|
|
|| def->undefined()
|
|
|| (def->declaredContent() != ElementDefinition::modelGroup
|
|
&& def->declaredContent() != ElementDefinition::any)
|
|
|| !def->canOmitStartTag())
|
|
break;
|
|
undoList.insert(new (internalAllocator()) UndoStartTag);
|
|
startImpliedCount++;
|
|
pushElement(new (internalAllocator()) OpenElement(e,
|
|
0,
|
|
0,
|
|
0,
|
|
Location()));
|
|
if (checkImplyLoop(startImpliedCount))
|
|
break;
|
|
for (size_t i = 0; i < def->nInclusions(); i++)
|
|
if (!elementIsExcluded(def->inclusion(i))) {
|
|
v.push_back(def->inclusion(i));
|
|
x.push_back(0);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// must be allowed #pcdata
|
|
v.push_back((const ElementType *)0);
|
|
x.push_back((PackedBoolean)0);
|
|
break;
|
|
}
|
|
}
|
|
undo(undoList);
|
|
// Remove exclusions and duplicates and undefined
|
|
size_t newSize = 0;
|
|
for (size_t i = 0; i < v.size(); i++)
|
|
if (!x[i] && (!v[i] || !v[i]->definition()->undefined())) {
|
|
Boolean dup = 0;
|
|
for (size_t j = 0; j < newSize; j++)
|
|
if (v[i] == v[j]) {
|
|
dup = 1;
|
|
break;
|
|
}
|
|
if (!dup)
|
|
v[newSize++] = v[i];
|
|
}
|
|
v.resize(newSize);
|
|
}
|
|
#endif
|
|
|
|
#ifdef SP_NAMESPACE
|
|
}
|
|
#endif
|