// Copyright (c) 1994, 1995 James Clark
// See the file COPYING for copying permission.
// Prolog, dtd and declaration parsing.
#include "splib.h"
#include "Parser.h"
#include "Param.h"
#include "Markup.h"
#include "ParserMessages.h"
#include "MessageArg.h"
#include "TokenMessageArg.h"
#include "token.h"
#include "macros.h"
#include <stdio.h>
#ifdef SP_NAMESPACE
namespace SP_NAMESPACE {
#endif
static const AllowedParams allowMdc(Param::mdc);
static const AllowedParams allowName(Param::name);
static const AllowedParams allowParamLiteral(Param::paramLiteral);
static const AllowedParams allowNameNameGroup(Param::name, Param::nameGroup);
static const AllowedParams allowDsoMdc(Param::dso, Param::mdc);
static AllowedParams allowNameMdc(Param::name, Param::mdc);
static AllowedParams
allowExplicitLinkRuleMdc(Param::mdc,
Param::name,
Param::nameGroup,
Param::indicatedReservedName + Syntax::rIMPLIED);
static AllowedParams
allowNameNameGroupMdc(Param::name, Param::nameGroup, Param::mdc);
static const AllowedParams
allowLinkSetSpec(Param::name,
Param::indicatedReservedName + Syntax::rINITIAL,
Param::indicatedReservedName + Syntax::rEMPTY,
Param::indicatedReservedName + Syntax::rRESTORE);
void Parser::doProlog()
{
const unsigned maxTries = 10;
unsigned tries = 0;
do {
if (cancelled()) {
allDone();
return;
}
Token token = getToken(proMode);
switch (token) {
case tokenUnrecognized:
if (reportNonSgmlCharacter())
break;
if (hadDtd()) {
currentInput()->ungetToken();
endProlog();
return;
}
{
StringC gi;
if (lookingAtStartTag(gi)) {
currentInput()->ungetToken();
implyDtd(gi);
return;
}
}
if (++tries >= maxTries) {
message(ParserMessages::notSgml);
giveUp();
return;
}
message(ParserMessages::prologCharacter, StringMessageArg(currentToken()));
prologRecover();
break;
case tokenEe:
if (hadDtd()) {
endProlog();
return;
}
message(ParserMessages::documentEndProlog);
allDone();
return;
case tokenMdoMdc:
// empty comment
emptyCommentDecl();
break;
case tokenMdoCom:
if (!parseCommentDecl())
prologRecover();
break;
case tokenMdoNameStart:
setPass2Start();
if (startMarkup(eventsWanted().wantPrologMarkup(), currentLocation()))
currentMarkup()->addDelim(Syntax::dMDO);
Syntax::ReservedName name;
if (parseDeclarationName(&name)) {
switch (name) {
case Syntax::rDOCTYPE:
if (!parseDoctypeDeclStart())
giveUp();
return;
case Syntax::rLINKTYPE:
if (!parseLinktypeDeclStart())
giveUp();
return;
case Syntax::rELEMENT:
case Syntax::rATTLIST:
case Syntax::rENTITY:
case Syntax::rNOTATION:
case Syntax::rSHORTREF:
case Syntax::rUSEMAP:
case Syntax::rUSELINK:
case Syntax::rLINK:
case Syntax::rIDLINK:
message(ParserMessages::prologDeclaration,
StringMessageArg(syntax().reservedName(name)));
if (!hadDtd())
tries++;
prologRecover();
break;
default:
message(ParserMessages::noSuchDeclarationType,
StringMessageArg(syntax().reservedName(name)));
prologRecover();
break;
}
}
else
prologRecover();
break;
case tokenPio:
if (!parseProcessingInstruction())
prologRecover();
break;
case tokenS:
if (eventsWanted().wantPrologMarkup()) {
extendS();
eventHandler().sSep(new (eventAllocator())
SSepEvent(currentInput()->currentTokenStart(),
currentInput()->currentTokenLength(),
currentLocation(),
1));
}
break;
default:
CANNOT_HAPPEN();
}
} while (eventQueueEmpty());
}
void Parser::endProlog()
{
if (baseDtd().isNull()
#if 0
|| baseDtd()->documentElementType()->definition()->undefined()
#endif
) {
// We could continue, but there's not a lot of point.
giveUp();
return;
}
if (maybeStartPass2())
setPhase(prologPhase);
else {
if (inputLevel() == 0) {
allDone();
return;
}
if (pass2())
checkEntityStability();
setPhase(instanceStartPhase);
startInstance();
ConstPtr<ComplexLpd> lpd;
Vector<AttributeList> simpleLinkAtts;
Vector<StringC> simpleLinkNames;
for (size_t i = 0; i < nActiveLink(); i++)
if (activeLpd(i).type() == Lpd::simpleLink) {
const SimpleLpd &lpd = (SimpleLpd &)activeLpd(i);
simpleLinkNames.push_back(lpd.name());
simpleLinkAtts.resize(simpleLinkAtts.size() + 1);
simpleLinkAtts.back().init(lpd.attributeDef());
simpleLinkAtts.back().finish(*this);
}
else
lpd = (ComplexLpd *)&activeLpd(i);
eventHandler().endProlog(new (eventAllocator())
EndPrologEvent(currentDtdPointer(),
lpd,
simpleLinkNames,
simpleLinkAtts,
currentLocation()));
}
}
void Parser::prologRecover()
{
unsigned skipCount = 0;
const unsigned skipMax = 250;
for (;;) {
Token token = getToken(proMode);
skipCount++;
if (token == tokenUnrecognized) {
token = getToken(mdMode);
if (token == tokenMdc) {
token = getToken(proMode);
if (token == tokenS)
return;
}
}
switch (token) {
case tokenUnrecognized:
(void)getChar();
break;
case tokenEe:
return;
case tokenMdoMdc:
case tokenMdoCom:
case tokenMdoNameStart:
case tokenPio:
currentInput()->ungetToken();
return;
case tokenS:
if (currentChar() == syntax().standardFunction(Syntax::fRE)
&& skipCount >= skipMax)
return;
default:
break;
}
}
}
void Parser::doDeclSubset()
{
do {
if (cancelled()) {
allDone();
return;
}
Token token = getToken(currentMode());
unsigned startLevel = inputLevel();
Boolean inDtd = !haveDefLpd();
switch (token) {
case tokenUnrecognized:
if (reportNonSgmlCharacter())
break;
message(ParserMessages::declSubsetCharacter, StringMessageArg(currentToken()));
declSubsetRecover(startLevel);
break;
case tokenEe:
if (inputLevel() == specialParseInputLevel()) {
// FIXME have separate messages for each type of special parse
message(ParserMessages::specialParseEntityEnd);
}
if (eventsWanted().wantPrologMarkup())
eventHandler().entityEnd(new (eventAllocator())
EntityEndEvent(currentLocation()));
if (inputLevel() == 2) {
const EntityDecl *e
= currentLocation().origin()->entityDecl();
if (e
&& (e->declType() == EntityDecl::doctype
|| e->declType() == EntityDecl::linktype)) {
// popInputStack may destroy e
Boolean fake = e->defLocation().origin().isNull();
popInputStack();
if (!(inDtd
? parseDoctypeDeclEnd(fake)
: parseLinktypeDeclEnd()))
; // FIXME recover
setPhase(prologPhase);
return;
}
}
if (inputLevel() == 1) {
if (finalPhase() == declSubsetPhase) {
checkDtd(defDtd());
endDtd();
}
else
// Give message before popping stack.
message(inDtd
? ParserMessages::documentEndDtdSubset
: ParserMessages::documentEndLpdSubset);
popInputStack();
allDone();
}
else
popInputStack();
return;
case tokenDsc: // end of declaration subset
// FIXME what's the right location?
if (!referenceDsEntity(currentLocation())) {
if (!(inDtd ? parseDoctypeDeclEnd() : parseLinktypeDeclEnd()))
; // FIXME recover
setPhase(prologPhase);
}
return;
case tokenMdoNameStart: // named markup declaration
if (startMarkup(eventsWanted().wantPrologMarkup(), currentLocation()))
currentMarkup()->addDelim(Syntax::dMDO);
Syntax::ReservedName name;
Boolean result;
if (parseDeclarationName(&name,
inDtd && !options().errorAfdr)) {
switch (name) {
case Syntax::rANY: // used for <!AFDR
result = parseAfdrDecl();
break;
case Syntax::rELEMENT:
if (inDtd)
result = parseElementDecl();
else {
message(ParserMessages::lpdSubsetDeclaration,
StringMessageArg(syntax().reservedName(name)));
result = 0;
}
break;
case Syntax::rATTLIST:
result = parseAttlistDecl();
break;
case Syntax::rENTITY:
result = parseEntityDecl();
break;
case Syntax::rNOTATION:
result = parseNotationDecl();
if (!inDtd && !sd().www())
message(ParserMessages::lpdSubsetDeclaration,
StringMessageArg(syntax().reservedName(name)));
break;
case Syntax::rSHORTREF:
if (inDtd)
result = parseShortrefDecl();
else {
message(ParserMessages::lpdSubsetDeclaration,
StringMessageArg(syntax().reservedName(name)));
result = 0;
}
break;
case Syntax::rUSEMAP:
if (inDtd)
result = parseUsemapDecl();
else {
message(ParserMessages::lpdSubsetDeclaration,
StringMessageArg(syntax().reservedName(name)));
result = 0;
}
break;
case Syntax::rLINK:
if (inDtd) {
message(ParserMessages::dtdSubsetDeclaration,
StringMessageArg(syntax().reservedName(name)));
result = 0;
}
else
result = parseLinkDecl();
break;
case Syntax::rIDLINK:
if (inDtd) {
message(ParserMessages::dtdSubsetDeclaration,
StringMessageArg(syntax().reservedName(name)));
result = 0;
}
else
result = parseIdlinkDecl();
break;
case Syntax::rDOCTYPE:
case Syntax::rLINKTYPE:
case Syntax::rUSELINK:
result = 0;
message(inDtd
? ParserMessages::dtdSubsetDeclaration
: ParserMessages::lpdSubsetDeclaration,
StringMessageArg(syntax().reservedName(name)));
break;
default:
result = 0;
message(ParserMessages::noSuchDeclarationType,
StringMessageArg(syntax().reservedName(name)));
break;
}
}
else
result = 0;
if (!result)
declSubsetRecover(startLevel);
break;
case tokenMdoMdc: // empty comment declaration
// empty comment
emptyCommentDecl();
break;
case tokenMdoCom: // comment declaration
if (!parseCommentDecl())
declSubsetRecover(startLevel);
break;
case tokenMdoDso: // marked section declaration
if (!parseMarkedSectionDeclStart())
declSubsetRecover(startLevel);
break;
case tokenMscMdc:
handleMarkedSectionEnd();
break;
case tokenPeroGrpo: // parameter entity reference with name group
message(ParserMessages::peroGrpoProlog);
// fall through
case tokenPeroNameStart: // parameter entity reference
{
ConstPtr<Entity> entity;
Ptr<EntityOrigin> origin;
if (parseEntityReference(1, token == tokenPeroGrpo, entity, origin)) {
if (!entity.isNull())
entity->dsReference(*this, origin);
}
else
declSubsetRecover(startLevel);
}
break;
case tokenPio: // processing instruction
if (!parseProcessingInstruction())
declSubsetRecover(startLevel);
break;
case tokenS: // white space
if (eventsWanted().wantPrologMarkup()) {
extendS();
eventHandler().sSep(new (eventAllocator())
SSepEvent(currentInput()->currentTokenStart(),
currentInput()->currentTokenLength(),
currentLocation(),
1));
}
break;
case tokenIgnoredChar:
// from an ignored marked section
if (eventsWanted().wantPrologMarkup())
eventHandler().ignoredChars(new (eventAllocator())
IgnoredCharsEvent(currentInput()->currentTokenStart(),
currentInput()->currentTokenLength(),
currentLocation(),
1));
break;
case tokenRe:
case tokenRs:
case tokenCroNameStart:
case tokenCroDigit:
case tokenHcroHexDigit:
case tokenEroNameStart:
case tokenEroGrpo:
case tokenChar:
// these can occur in a cdata or rcdata marked section
message(ParserMessages::dataMarkedSectionDeclSubset);
declSubsetRecover(startLevel);
break;
default:
CANNOT_HAPPEN();
}
} while (eventQueueEmpty());
}
void Parser::declSubsetRecover(unsigned startLevel)
{
for (;;) {
Token token = getToken(currentMode());
switch (token) {
case tokenUnrecognized:
(void)getChar();
break;
case tokenEe:
if (inputLevel() <= startLevel)
return;
popInputStack();
break;
case tokenMdoCom:
case tokenDsc:
case tokenMdoNameStart:
case tokenMdoMdc:
case tokenMdoDso:
case tokenMscMdc:
case tokenPio:
if (inputLevel() == startLevel) {
currentInput()->ungetToken();
return;
}
break;
default:
break;
}
}
}
Boolean Parser::lookingAtStartTag(StringC &gi)
{
// This is harder than might be expected since we may not have compiled
// the recognizers for the instance yet.
const StringC &stago = instanceSyntax().delimGeneral(Syntax::dSTAGO);
for (size_t i = currentInput()->currentTokenLength();
i < stago.size();
i++)
if (currentInput()->tokenChar(messenger()) == InputSource::eE)
return 0;
StringC delim;
getCurrentToken(instanceSyntax().generalSubstTable(), delim);
if (delim != stago)
return 0;
Xchar c = currentInput()->tokenChar(messenger());
if (!instanceSyntax().isNameStartCharacter(c))
return 0;
do {
gi += (*instanceSyntax().generalSubstTable())[(Char)c];
c = currentInput()->tokenChar(messenger());
} while (instanceSyntax().isNameCharacter(c));
return 1;
}
Boolean Parser::parseDeclarationName(Syntax::ReservedName *result,
Boolean allowAfdr)
{
currentInput()->discardInitial();
extendNameToken(syntax().namelen(), ParserMessages::nameLength);
StringC &name = nameBuffer();
getCurrentToken(syntax().generalSubstTable(), name);
if (!syntax().lookupReservedName(name, result)) {
if (allowAfdr && name == sd().execToInternal("AFDR")) {
*result = Syntax::rANY;
if (currentMarkup())
currentMarkup()->addName(currentInput());
}
else {
message(ParserMessages::noSuchDeclarationType, StringMessageArg(name));
return 0;
}
}
else if (currentMarkup())
currentMarkup()->addReservedName(*result, currentInput());
return 1;
}
Boolean Parser::parseElementDecl()
{
unsigned declInputLevel = inputLevel();
Param parm;
if (!parseParam(allowNameNameGroup, declInputLevel, parm))
return 0;
Vector<NameToken> nameVector;
if (parm.type == Param::nameGroup) {
parm.nameTokenVector.swap(nameVector);
if (options().warnElementGroupDecl)
message(ParserMessages::elementGroupDecl);
}
else {
nameVector.resize(1);
parm.token.swap(nameVector[0].name);
parm.origToken.swap(nameVector[0].origName);
}
static AllowedParams
allowRankOmissionContent(Param::number,
Param::reservedName + Syntax::rO,
Param::minus,
Param::reservedName + Syntax::rCDATA,
Param::reservedName + Syntax::rRCDATA,
Param::reservedName + Syntax::rEMPTY,
Param::reservedName + Syntax::rANY,
Param::modelGroup);
if (!parseParam(allowRankOmissionContent, declInputLevel, parm))
return 0;
StringC rankSuffix;
Vector<ElementType *> elements(nameVector.size());
Vector<RankStem *> rankStems;
Vector<const RankStem *> constRankStems;
size_t i;
if (parm.type == Param::number) {
if (options().warnRank)
message(ParserMessages::rank);
parm.token.swap(rankSuffix);
rankStems.resize(nameVector.size());
constRankStems.resize(nameVector.size());
for (i = 0; i < elements.size(); i++) {
StringC name(nameVector[i].name);
name += rankSuffix;
if (name.size() > syntax().namelen()
&& nameVector[i].name.size() <= syntax().namelen())
message(ParserMessages::genericIdentifierLength,
NumberMessageArg(syntax().namelen()));
elements[i] = lookupCreateElement(name);
rankStems[i] = lookupCreateRankStem(nameVector[i].name);
constRankStems[i] = rankStems[i];
}
static AllowedParams
allowOmissionContent(Param::reservedName + Syntax::rO,
Param::minus,
Param::reservedName + Syntax::rCDATA,
Param::reservedName + Syntax::rRCDATA,
Param::reservedName + Syntax::rEMPTY,
Param::reservedName + Syntax::rANY,
Param::modelGroup);
Token token = getToken(mdMinusMode);
if (token == tokenNameStart)
message(ParserMessages::psRequired);
currentInput()->ungetToken();
if (!parseParam(allowOmissionContent, declInputLevel, parm))
return 0;
}
else {
for (i = 0; i < elements.size(); i++) {
// StringC *origName;
// origName = new StringC(nameVector[i].origName);
elements[i] = lookupCreateElement(nameVector[i].name);
elements[i]->setOrigName(nameVector[i].origName);
}
}
for (i = 0; i < elements.size(); i++)
if (defDtd().lookupRankStem(elements[i]->name()) && validate())
message(ParserMessages::rankStemGenericIdentifier,
StringMessageArg(elements[i]->name()));
unsigned char omitFlags = 0;
if (parm.type == Param::minus
|| parm.type == Param::reservedName + Syntax::rO) {
if (options().warnMinimizationParam)
message(ParserMessages::minimizationParam);
omitFlags |= ElementDefinition::omitSpec;
if (parm.type != Param::minus)
omitFlags |= ElementDefinition::omitStart;
static AllowedParams allowOmission(Param::reservedName + Syntax::rO,
Param::minus);
if (!parseParam(allowOmission, declInputLevel, parm))
return 0;
if (parm.type != Param::minus)
omitFlags |= ElementDefinition::omitEnd;
static AllowedParams allowContent(Param::reservedName + Syntax::rCDATA,
Param::reservedName + Syntax::rRCDATA,
Param::reservedName + Syntax::rEMPTY,
Param::reservedName + Syntax::rANY,
Param::modelGroup);
if (!parseParam(allowContent, declInputLevel, parm))
return 0;
}
else {
if (sd().omittag())
message(ParserMessages::missingTagMinimization);
}
Ptr<ElementDefinition> def;
switch (parm.type) {
case Param::reservedName + Syntax::rCDATA:
def = new ElementDefinition(markupLocation(),
defDtd().allocElementDefinitionIndex(),
omitFlags,
ElementDefinition::cdata);
if (!parseParam(allowMdc, declInputLevel, parm))
return 0;
if (options().warnCdataContent)
message(ParserMessages::cdataContent);
break;
case Param::reservedName + Syntax::rRCDATA:
def = new ElementDefinition(markupLocation(),
defDtd().allocElementDefinitionIndex(),
omitFlags,
ElementDefinition::rcdata);
if (!parseParam(allowMdc, declInputLevel, parm))
return 0;
if (options().warnRcdataContent)
message(ParserMessages::rcdataContent);
break;
case Param::reservedName + Syntax::rEMPTY:
def = new ElementDefinition(markupLocation(),
defDtd().allocElementDefinitionIndex(),
omitFlags,
ElementDefinition::empty);
if ((omitFlags & ElementDefinition::omitSpec)
&& !(omitFlags & ElementDefinition::omitEnd)
&& options().warnShould)
message(ParserMessages::emptyOmitEndTag);
if (!parseParam(allowMdc, declInputLevel, parm))
return 0;
break;
case Param::reservedName + Syntax::rANY:
def = new ElementDefinition(markupLocation(),
defDtd().allocElementDefinitionIndex(),
omitFlags,
ElementDefinition::any);
if (!parseExceptions(declInputLevel, def))
return 0;
break;
case Param::modelGroup:
{
unsigned long cnt = parm.modelGroupPtr->grpgtcnt();
// The outermost model group isn't formally a content token.
if (cnt - 1 > syntax().grpgtcnt())
message(ParserMessages::grpgtcnt, NumberMessageArg(syntax().grpgtcnt()));
Owner<CompiledModelGroup>
modelGroup(new CompiledModelGroup(parm.modelGroupPtr));
Vector<ContentModelAmbiguity> ambiguities;
Boolean pcdataUnreachable;
modelGroup->compile(currentDtd().nElementTypeIndex(), ambiguities,
pcdataUnreachable);
if (pcdataUnreachable && options().warnMixedContent)
message(ParserMessages::pcdataUnreachable);
if (validate()) {
for (i = 0; i < ambiguities.size(); i++) {
const ContentModelAmbiguity &a = ambiguities[i];
reportAmbiguity(a.from, a.to1, a.to2, a.andDepth);
}
}
def = new ElementDefinition(markupLocation(),
defDtd().allocElementDefinitionIndex(),
omitFlags,
ElementDefinition::modelGroup,
modelGroup);
if (!parseExceptions(declInputLevel, def))
return 0;
}
break;
}
if (rankSuffix.size() > 0)
def->setRank(rankSuffix, constRankStems);
ConstPtr<ElementDefinition> constDef(def);
for (i = 0; i < elements.size(); i++) {
if (elements[i]->definition() != 0) {
if (validate())
message(ParserMessages::duplicateElementDefinition,
StringMessageArg(elements[i]->name()));
}
else {
elements[i]->setElementDefinition(constDef, i);
if (!elements[i]->attributeDef().isNull())
checkElementAttribute(elements[i]);
}
if (rankStems.size() > 0)
rankStems[i]->addDefinition(constDef);
}
if (currentMarkup()) {
Vector<const ElementType *> v(elements.size());
for (i = 0; i < elements.size(); i++)
v[i] = elements[i];
eventHandler().elementDecl(new (eventAllocator())
ElementDeclEvent(v, currentDtdPointer(),
markupLocation(),
currentMarkup()));
}
return 1;
}
void Parser::reportAmbiguity(const LeafContentToken *from,
const LeafContentToken *to1,
const LeafContentToken *to2,
unsigned ambigAndDepth)
{
StringC toName;
const ElementType *toType = to1->elementType();
if (toType)
toName = toType->name();
else {
toName = syntax().delimGeneral(Syntax::dRNI);
toName += syntax().reservedName(Syntax::rPCDATA);
}
unsigned to1Index = to1->typeIndex() + 1;
unsigned to2Index = to2->typeIndex() + 1;
if (from->isInitial())
message(ParserMessages::ambiguousModelInitial,
StringMessageArg(toName),
OrdinalMessageArg(to1Index),
OrdinalMessageArg(to2Index));
else {
StringC fromName;
const ElementType *fromType = from->elementType();
if (fromType)
fromName = fromType->name();
else {
fromName = syntax().delimGeneral(Syntax::dRNI);
fromName += syntax().reservedName(Syntax::rPCDATA);
}
unsigned fromIndex = from->typeIndex() + 1;
unsigned andMatches = from->andDepth() - ambigAndDepth;
if (andMatches == 0)
message(ParserMessages::ambiguousModel,
StringMessageArg(fromName),
OrdinalMessageArg(fromIndex),
StringMessageArg(toName),
OrdinalMessageArg(to1Index),
OrdinalMessageArg(to2Index));
else if (andMatches == 1)
message(ParserMessages::ambiguousModelSingleAnd,
StringMessageArg(fromName),
OrdinalMessageArg(fromIndex),
StringMessageArg(toName),
OrdinalMessageArg(to1Index),
OrdinalMessageArg(to2Index));
else
message(ParserMessages::ambiguousModelMultipleAnd,
StringMessageArg(fromName),
OrdinalMessageArg(fromIndex),
NumberMessageArg(andMatches),
StringMessageArg(toName),
OrdinalMessageArg(to1Index),
OrdinalMessageArg(to2Index));
}
}
// Check the compatibility of the attribute definition with
// the element definition.
void Parser::checkElementAttribute(const ElementType *e, size_t checkFrom)
{
if (!validate())
return;
const AttributeDefinitionList *attDef = e->attributeDef().pointer();
Boolean conref = 0;
ASSERT(e != 0);
const ElementDefinition *edef = e->definition();
ASSERT(edef != 0);
ASSERT(attDef != 0);
size_t attDefLength = attDef->size();
for (size_t i = checkFrom; i < attDefLength; i++) {
const AttributeDefinition *p = attDef->def(i);
if (p->isConref())
conref = 1;
if (p->isNotation()
&& edef->declaredContent() == ElementDefinition::empty)
message(ParserMessages::notationEmpty, StringMessageArg(e->name()));
}
if (conref) {
#if 0
if (edef->omittedTagSpec() && !edef->canOmitEndTag()
&& options().warnShould)
message(ParserMessages::conrefOmitEndTag, StringMessageArg(e->name()));
#endif
if (edef->declaredContent() == ElementDefinition::empty)
message(ParserMessages::conrefEmpty, StringMessageArg(e->name()));
}
}
ElementType *Parser::lookupCreateElement(const StringC &name)
{
ElementType *e = defDtd().lookupElementType(name);
if (!e) {
if (haveDefLpd())
message(ParserMessages::noSuchSourceElement, StringMessageArg(name));
else {
e = new ElementType(name, defDtd().allocElementTypeIndex());
defDtd().insertElementType(e);
}
}
return e;
}
RankStem *Parser::lookupCreateRankStem(const StringC &name)
{
RankStem *r = defDtd().lookupRankStem(name);
if (!r) {
r = new RankStem(name, defDtd().nRankStem());
defDtd().insertRankStem(r);
const ElementType *e = defDtd().lookupElementType(name);
if (e && e->definition() != 0)
message(ParserMessages::rankStemGenericIdentifier, StringMessageArg(name));
}
return r;
}
Boolean Parser::parseExceptions(unsigned declInputLevel,
Ptr<ElementDefinition> &def)
{
Param parm;
static AllowedParams
allowExceptionsMdc(Param::mdc, Param::exclusions, Param::inclusions);
if (!parseParam(allowExceptionsMdc, declInputLevel, parm))
return 0;
if (parm.type == Param::exclusions) {
if (options().warnExclusion)
message(ParserMessages::exclusion);
def->setExclusions(parm.elementVector);
static AllowedParams allowInclusionsMdc(Param::mdc, Param::inclusions);
if (!parseParam(allowInclusionsMdc, declInputLevel, parm))
return 0;
}
if (parm.type == Param::inclusions) {
if (options().warnInclusion)
message(ParserMessages::inclusion);
def->setInclusions(parm.elementVector);
size_t nI = def->nInclusions();
size_t nE = def->nExclusions();
if (nE) {
for (size_t i = 0; i < nI; i++) {
const ElementType *e = def->inclusion(i);
for (size_t j = 0; j < nE; j++)
if (def->exclusion(j) == e)
message(ParserMessages::excludeIncludeSame,
StringMessageArg(e->name()));
}
}
if (!parseParam(allowMdc, declInputLevel, parm))
return 0;
}
return 1;
}
Boolean Parser::parseAttlistDecl()
{
unsigned declInputLevel = inputLevel();
Param parm;
size_t attcnt = 0;
size_t idIndex = size_t(-1);
size_t notationIndex = size_t(-1);
Boolean anyCurrent = 0;
Boolean isNotation;
Vector<Attributed *> attributed;
if (!parseAttributed(declInputLevel, parm, attributed, isNotation))
return 0;
Vector<CopyOwner<AttributeDefinition> > defs;
if (!parseParam(sd().www() ? allowNameMdc : allowName, declInputLevel, parm))
return 0;
while (parm.type != Param::mdc) {
StringC attributeName;
StringC origAttributeName;
parm.token.swap(attributeName);
parm.origToken.swap(origAttributeName);
attcnt++;
Boolean duplicate = 0;
size_t i;
for (i = 0; i < defs.size(); i++)
if (defs[i]->name() == attributeName) {
message(ParserMessages::duplicateAttributeDef,
StringMessageArg(attributeName));
duplicate = 1;
break;
}
Owner<DeclaredValue> declaredValue;
if (!parseDeclaredValue(declInputLevel, isNotation, parm, declaredValue))
return 0;
if (!duplicate) {
if (declaredValue->isId()) {
if (idIndex != size_t(-1))
message(ParserMessages::multipleIdAttributes,
StringMessageArg(defs[idIndex]->name()));
idIndex = defs.size();
}
else if (declaredValue->isNotation()) {
if (notationIndex != size_t(-1))
message(ParserMessages::multipleNotationAttributes,
StringMessageArg(defs[notationIndex]->name()));
notationIndex = defs.size();
}
}
const Vector<StringC> *tokensPtr = declaredValue->getTokens();
if (tokensPtr) {
size_t nTokens = tokensPtr->size();
if (!sd().www()) {
Vector<StringC>::const_iterator tokens = tokensPtr->begin();
for (i = 0; i < nTokens; i++) {
for (size_t j = 0; j < defs.size(); j++)
if (defs[j]->containsToken(tokens[i])) {
message(ParserMessages::duplicateAttributeToken,
StringMessageArg(tokens[i]));
break;
}
}
}
attcnt += nTokens;
}
Owner<AttributeDefinition> def;
if (!parseDefaultValue(declInputLevel, isNotation, parm, attributeName,
declaredValue, def, anyCurrent))
return 0;
if (haveDefLpd() && defLpd().type() == Lpd::simpleLink && !def->isFixed())
message(ParserMessages::simpleLinkFixedAttribute);
def->setOrigName(origAttributeName);
if (!duplicate) {
defs.resize(defs.size() + 1);
defs.back() = def.extract();
}
static AllowedParams allowNameMdc(Param::name, Param::mdc);
if (!parseParam(allowNameMdc, declInputLevel, parm))
return 0;
}
if (attcnt > syntax().attcnt())
message(ParserMessages::attcnt,
NumberMessageArg(attcnt),
NumberMessageArg(syntax().attcnt()));
if (haveDefLpd() && !isNotation) {
if (defLpd().type() == Lpd::simpleLink) {
for (size_t i = 0; i < attributed.size(); i++) {
const ElementType *e = (const ElementType *)attributed[i];
if (e) {
if (e->name() == defLpd().sourceDtd()->name()) {
SimpleLpd &lpd = (SimpleLpd &)defLpd();
if (lpd.attributeDef().isNull())
lpd.setAttributeDef(new AttributeDefinitionList(defs, 0));
else
message(ParserMessages::duplicateAttlistElement,
StringMessageArg(e->name()));
}
else
message(ParserMessages::simpleLinkAttlistElement,
StringMessageArg(e->name()));
}
}
}
else {
Ptr<AttributeDefinitionList>
adl(new AttributeDefinitionList(defs,
defComplexLpd()
.allocAttributeDefinitionListIndex()));
for (size_t i = 0; i < attributed.size(); i++) {
const ElementType *e = (const ElementType *)attributed[i];
if (e) {
if (defComplexLpd().attributeDef(e).isNull())
defComplexLpd().setAttributeDef(e, adl);
else
message(ParserMessages::duplicateAttlistElement,
StringMessageArg(e->name()));
}
}
}
}
else {
Ptr<AttributeDefinitionList>
adl(new AttributeDefinitionList(defs,
defDtd()
.allocAttributeDefinitionListIndex(),
anyCurrent,
idIndex,
notationIndex));
for (size_t i = 0; i < attributed.size(); i++) {
if (attributed[i]->attributeDef().isNull()) {
attributed[i]->setAttributeDef(adl);
if (!isNotation) {
ElementType *e = (ElementType *)attributed[i];
if (e->definition() != 0)
checkElementAttribute(e);
}
}
else if (options().errorAfdr && !sd().www()) {
if (isNotation)
message(ParserMessages::duplicateAttlistNotation,
StringMessageArg(((Notation *)attributed[i])->name()));
else
message(ParserMessages::duplicateAttlistElement,
StringMessageArg(((ElementType *)attributed[i])->name()));
}
else {
if (!hadAfdrDecl() && !sd().www()) {
message(ParserMessages::missingAfdrDecl);
setHadAfdrDecl();
}
AttributeDefinitionList *curAdl;
{
// Use block to make sure temporary gets destroyed.
curAdl = attributed[i]->attributeDef().pointer();
}
size_t oldSize = curAdl->size();
if (curAdl->count() != 1) {
Vector<CopyOwner<AttributeDefinition> > copy(oldSize);
for (size_t j = 0; j < oldSize; j++)
copy[j] = curAdl->def(j)->copy();
Ptr<AttributeDefinitionList> adlCopy
= new AttributeDefinitionList(copy,
defDtd().allocAttributeDefinitionListIndex(),
curAdl->anyCurrent(),
curAdl->idIndex(),
curAdl->notationIndex());
attributed[i]->setAttributeDef(adlCopy);
curAdl = adlCopy.pointer();
}
for (size_t j = 0; j < adl->size(); j++) {
unsigned index;
if (!curAdl->attributeIndex(adl->def(j)->name(), index)) {
index = curAdl->idIndex();
if (index != -1 && adl->def(j)->isId())
message(ParserMessages::multipleIdAttributes,
StringMessageArg(curAdl->def(index)->name()));
index = curAdl->notationIndex();
if (index != -1 && adl->def(j)->isNotation())
message(ParserMessages::multipleNotationAttributes,
StringMessageArg(curAdl->def(index)->name()));
curAdl->append(adl->def(j)->copy());
}
else {
Boolean tem;
if (curAdl->def(index)->isSpecified(tem))
message(ParserMessages::specifiedAttributeRedeclared,
StringMessageArg(adl->def(j)->name()));
}
}
if (!isNotation) {
ElementType *e = (ElementType *)attributed[i];
if (e->definition() != 0)
checkElementAttribute(e, oldSize);
}
}
}
}
if (currentMarkup()) {
if (isNotation) {
Vector<ConstPtr<Notation> > v(attributed.size());
for (size_t i = 0; i < attributed.size(); i++)
v[i] = (Notation *)attributed[i];
eventHandler()
.attlistNotationDecl(new (eventAllocator())
AttlistNotationDeclEvent(v,
markupLocation(),
currentMarkup()));
}
else {
Vector<const ElementType *> v(attributed.size());
for (size_t i = 0; i < attributed.size(); i++)
v[i] = (ElementType *)attributed[i];
if (haveDefLpd())
eventHandler()
.linkAttlistDecl(new (eventAllocator())
LinkAttlistDeclEvent(v,
defLpdPointer(),
markupLocation(),
currentMarkup()));
else
eventHandler().attlistDecl(new (eventAllocator())
AttlistDeclEvent(v,
currentDtdPointer(),
markupLocation(),
currentMarkup()));
}
}
if (isNotation) {
Dtd::EntityIter entityIter(defDtd().generalEntityIter());
for (;;) {
Ptr<Entity> entity(entityIter.next());
if (entity.isNull())
break;
const ExternalDataEntity *external = entity->asExternalDataEntity();
if (external) {
const Notation *entityNotation = external->notation();
for (size_t i = 0; i < attributed.size(); i++)
if ((Notation *)attributed[i] == entityNotation) {
AttributeList attributes(entityNotation->attributeDef());
attributes.finish(*this);
((ExternalDataEntity *)entity.pointer())
->setNotation((Notation *)attributed[i], attributes);
}
}
}
}
return 1;
}
Boolean Parser::parseAttributed(unsigned declInputLevel,
Param &parm,
Vector<Attributed *> &attributed,
Boolean &isNotation)
{
static AllowedParams
allowNameGroupNotation(Param::name,
Param::nameGroup,
Param::indicatedReservedName + Syntax::rNOTATION);
static AllowedParams
allowNameGroupNotationAll(Param::name,
Param::nameGroup,
Param::indicatedReservedName
+ Syntax::rNOTATION,
Param::indicatedReservedName
+ Syntax::rALL,
Param::indicatedReservedName
+ Syntax::rIMPLICIT);
if (!parseParam(haveDefLpd()
? allowNameGroupNotation
: allowNameGroupNotationAll,
declInputLevel, parm))
return 0;
if (parm.type == Param::indicatedReservedName + Syntax::rNOTATION) {
if (options().warnDataAttributes)
message(ParserMessages::dataAttributes);
isNotation = 1;
static AllowedParams
allowNameGroupAll(Param::name,
Param::nameGroup,
Param::indicatedReservedName + Syntax::rALL,
Param::indicatedReservedName + Syntax::rIMPLICIT);
if (!parseParam(haveDefLpd()
? allowNameNameGroup
: allowNameGroupAll,
declInputLevel, parm))
return 0;
if (parm.type == Param::nameGroup) {
attributed.resize(parm.nameTokenVector.size());
for (size_t i = 0; i < attributed.size(); i++)
attributed[i] = lookupCreateNotation(parm.nameTokenVector[i].name);
}
else {
if (parm.type != Param::name && !hadAfdrDecl() && !sd().www()) {
message(ParserMessages::missingAfdrDecl);
setHadAfdrDecl();
}
attributed.resize(1);
attributed[0]
= lookupCreateNotation(parm.type == Param::name
? parm.token
: syntax().rniReservedName(Syntax::ReservedName(parm.type - Param::indicatedReservedName)));
}
}
else {
isNotation = 0;
if (parm.type == Param::nameGroup) {
if (options().warnAttlistGroupDecl)
message(ParserMessages::attlistGroupDecl);
attributed.resize(parm.nameTokenVector.size());
for (size_t i = 0; i < attributed.size(); i++)
attributed[i] = lookupCreateElement(parm.nameTokenVector[i].name);
}
else {
if (parm.type != Param::name && !hadAfdrDecl() && !sd().www()) {
message(ParserMessages::missingAfdrDecl);
setHadAfdrDecl();
}
attributed.resize(1);
attributed[0]
= lookupCreateElement(parm.type == Param::name
? parm.token
: syntax().rniReservedName(Syntax::ReservedName(parm.type - Param::indicatedReservedName)));
}
}
return 1;
}
Boolean Parser::parseDeclaredValue(unsigned declInputLevel,
Boolean isNotation,
Param &parm,
Owner<DeclaredValue> &declaredValue)
{
static Param::Type declaredValues[] = {
Param::reservedName + Syntax::rCDATA,
Param::reservedName + Syntax::rENTITY,
Param::reservedName + Syntax::rENTITIES,
Param::reservedName + Syntax::rID,
Param::reservedName + Syntax::rIDREF,
Param::reservedName + Syntax::rIDREFS,
Param::reservedName + Syntax::rNAME,
Param::reservedName + Syntax::rNAMES,
Param::reservedName + Syntax::rNMTOKEN,
Param::reservedName + Syntax::rNMTOKENS,
Param::reservedName + Syntax::rNUMBER,
Param::reservedName + Syntax::rNUMBERS,
Param::reservedName + Syntax::rNUTOKEN,
Param::reservedName + Syntax::rNUTOKENS,
Param::reservedName + Syntax::rNOTATION,
Param::nameTokenGroup,
Param::reservedName + Syntax::rDATA
};
static AllowedParams allowDeclaredValue(declaredValues,
SIZEOF(declaredValues) - 1);
static AllowedParams allowDeclaredValueData(declaredValues,
SIZEOF(declaredValues));
if (!parseParam(sd().www() ? allowDeclaredValueData : allowDeclaredValue,
declInputLevel, parm))
return 0;
enum { asDataAttribute = 01, asLinkAttribute = 02 };
unsigned allowedFlags = asDataAttribute|asLinkAttribute;
switch (parm.type) {
case Param::reservedName + Syntax::rCDATA:
declaredValue = new CdataDeclaredValue;
break;
case Param::reservedName + Syntax::rENTITY:
declaredValue = new EntityDeclaredValue(0);
allowedFlags = asLinkAttribute;
break;
case Param::reservedName + Syntax::rENTITIES:
declaredValue = new EntityDeclaredValue(1);
allowedFlags = asLinkAttribute;
break;
case Param::reservedName + Syntax::rID:
declaredValue = new IdDeclaredValue;
allowedFlags = 0;
break;
case Param::reservedName + Syntax::rIDREF:
declaredValue = new IdrefDeclaredValue(0);
allowedFlags = 0;
break;
case Param::reservedName + Syntax::rIDREFS:
declaredValue = new IdrefDeclaredValue(1);
allowedFlags = 0;
break;
case Param::reservedName + Syntax::rNAME:
declaredValue
= new TokenizedDeclaredValue(TokenizedDeclaredValue::name, 0);
if (options().warnNameDeclaredValue)
message(ParserMessages::nameDeclaredValue);
break;
case Param::reservedName + Syntax::rNAMES:
declaredValue
= new TokenizedDeclaredValue(TokenizedDeclaredValue::name, 1);
if (options().warnNameDeclaredValue)
message(ParserMessages::nameDeclaredValue);
break;
case Param::reservedName + Syntax::rNMTOKEN:
declaredValue
= new TokenizedDeclaredValue(TokenizedDeclaredValue::nameToken, 0);
break;
case Param::reservedName + Syntax::rNMTOKENS:
declaredValue
= new TokenizedDeclaredValue(TokenizedDeclaredValue::nameToken, 1);
break;
case Param::reservedName + Syntax::rNUMBER:
declaredValue
= new TokenizedDeclaredValue(TokenizedDeclaredValue::number, 0);
if (options().warnNumberDeclaredValue)
message(ParserMessages::numberDeclaredValue);
break;
case Param::reservedName + Syntax::rNUMBERS:
declaredValue
= new TokenizedDeclaredValue(TokenizedDeclaredValue::number, 1);
if (options().warnNumberDeclaredValue)
message(ParserMessages::numberDeclaredValue);
break;
case Param::reservedName + Syntax::rNUTOKEN:
declaredValue
= new TokenizedDeclaredValue(TokenizedDeclaredValue::numberToken, 0);
if (options().warnNutokenDeclaredValue)
message(ParserMessages::nutokenDeclaredValue);
break;
case Param::reservedName + Syntax::rNUTOKENS:
declaredValue
= new TokenizedDeclaredValue(TokenizedDeclaredValue::numberToken, 1);
if (options().warnNutokenDeclaredValue)
message(ParserMessages::nutokenDeclaredValue);
break;
case Param::reservedName + Syntax::rNOTATION:
{
static AllowedParams allowNameGroup(Param::nameGroup);
if (!parseParam(allowNameGroup, declInputLevel, parm))
return 0;
Vector<StringC> group(parm.nameTokenVector.size());
for (size_t i = 0; i < group.size(); i++)
parm.nameTokenVector[i].name.swap(group[i]);
declaredValue = new NotationDeclaredValue(group);
allowedFlags = 0;
}
break;
case Param::nameTokenGroup:
{
Vector<StringC> group(parm.nameTokenVector.size());
Vector<StringC> origGroup(parm.nameTokenVector.size());
for (size_t i = 0; i < group.size(); i++) {
parm.nameTokenVector[i].name.swap(group[i]);
parm.nameTokenVector[i].origName.swap(origGroup[i]);
}
GroupDeclaredValue *grpVal = new NameTokenGroupDeclaredValue(group);
grpVal->setOrigAllowedValues(origGroup);
declaredValue = grpVal;
}
break;
case Param::reservedName + Syntax::rDATA:
{
if (!parseParam(allowName, declInputLevel, parm))
return 0;
Ptr<Notation> notation(lookupCreateNotation(parm.token));
static AllowedParams allowDsoSilentValue(Param::dso, Param::silent);
AttributeList attributes(notation->attributeDef());
if (parseParam(allowDsoSilentValue, declInputLevel, parm)
&& parm.type == Param::dso) {
if (attributes.size() == 0 && !sd().www())
message(ParserMessages::notationNoAttributes,
StringMessageArg(notation->name()));
Boolean netEnabling;
Ptr<AttributeDefinitionList> newAttDef;
if (!parseAttributeSpec(asMode, attributes, netEnabling, newAttDef))
return 0;
if (!newAttDef.isNull()) {
newAttDef->setIndex(defDtd().allocAttributeDefinitionListIndex());
notation->setAttributeDef(newAttDef);
}
if (attributes.nSpec() == 0)
message(ParserMessages::emptyDataAttributeSpec);
}
else {
attributes.finish(*this);
// unget the first token of the default value
currentInput()->ungetToken();
}
ConstPtr<Notation> nt(notation.pointer());
declaredValue = new DataDeclaredValue(nt, attributes);
}
break;
default:
CANNOT_HAPPEN();
}
if (isNotation) {
if (!(allowedFlags & asDataAttribute))
message(ParserMessages::dataAttributeDeclaredValue);
}
else if (haveDefLpd() && !isNotation && !(allowedFlags & asLinkAttribute))
message(ParserMessages::linkAttributeDeclaredValue);
return 1;
}
Boolean Parser::parseDefaultValue(unsigned declInputLevel,
Boolean isNotation,
Param &parm,
const StringC &attributeName,
Owner<DeclaredValue> &declaredValue,
Owner<AttributeDefinition> &def,
Boolean &anyCurrent)
{
// default value
static AllowedParams
allowDefaultValue(Param::indicatedReservedName + Syntax::rFIXED,
Param::indicatedReservedName + Syntax::rREQUIRED,
Param::indicatedReservedName + Syntax::rCURRENT,
Param::indicatedReservedName + Syntax::rCONREF,
Param::indicatedReservedName + Syntax::rIMPLIED,
Param::attributeValue,
Param::attributeValueLiteral);
static AllowedParams
allowTokenDefaultValue(Param::indicatedReservedName + Syntax::rFIXED,
Param::indicatedReservedName + Syntax::rREQUIRED,
Param::indicatedReservedName + Syntax::rCURRENT,
Param::indicatedReservedName + Syntax::rCONREF,
Param::indicatedReservedName + Syntax::rIMPLIED,
Param::attributeValue,
Param::tokenizedAttributeValueLiteral);
if (!parseParam(declaredValue->tokenized()
? allowTokenDefaultValue
: allowDefaultValue, declInputLevel, parm))
return 0;
switch (parm.type) {
case Param::indicatedReservedName + Syntax::rFIXED:
{
static AllowedParams allowValue(Param::attributeValue,
Param::attributeValueLiteral);
static AllowedParams
allowTokenValue(Param::attributeValue,
Param::tokenizedAttributeValueLiteral);
if (!parseParam(declaredValue->tokenized()
? allowTokenValue
: allowValue, declInputLevel, parm))
return 0;
unsigned specLength = 0;
AttributeValue *value = declaredValue->makeValue(parm.literalText,
*this,
attributeName,
specLength);
if (declaredValue->isId())
message(ParserMessages::idDeclaredValue);
def = new FixedAttributeDefinition(attributeName,
declaredValue.extract(),
value);
}
break;
case Param::attributeValue:
if (options().warnAttributeValueNotLiteral)
message(ParserMessages::attributeValueNotLiteral);
// fall through
case Param::attributeValueLiteral:
case Param::tokenizedAttributeValueLiteral:
{
unsigned specLength = 0;
AttributeValue *value = declaredValue->makeValue(parm.literalText,
*this,
attributeName,
specLength);
if (declaredValue->isId())
message(ParserMessages::idDeclaredValue);
def = new DefaultAttributeDefinition(attributeName,
declaredValue.extract(),
value);
}
break;
case Param::indicatedReservedName + Syntax::rREQUIRED:
def = new RequiredAttributeDefinition(attributeName,
declaredValue.extract());
break;
case Param::indicatedReservedName + Syntax::rCURRENT:
anyCurrent = 1;
if (declaredValue->isId())
message(ParserMessages::idDeclaredValue);
def = new CurrentAttributeDefinition(attributeName,
declaredValue.extract(),
defDtd().allocCurrentAttributeIndex());
if (isNotation)
message(ParserMessages::dataAttributeDefaultValue);
else if (haveDefLpd())
message(ParserMessages::linkAttributeDefaultValue);
else if (options().warnCurrent)
message(ParserMessages::currentAttribute);
break;
case Param::indicatedReservedName + Syntax::rCONREF:
if (declaredValue->isId())
message(ParserMessages::idDeclaredValue);
if (declaredValue->isNotation())
message(ParserMessages::notationConref);
def = new ConrefAttributeDefinition(attributeName,
declaredValue.extract());
if (isNotation)
message(ParserMessages::dataAttributeDefaultValue);
else if (haveDefLpd())
message(ParserMessages::linkAttributeDefaultValue);
else if (options().warnConref)
message(ParserMessages::conrefAttribute);
break;
case Param::indicatedReservedName + Syntax::rIMPLIED:
def = new ImpliedAttributeDefinition(attributeName,
declaredValue.extract());
break;
default:
CANNOT_HAPPEN();
}
return 1;
}
// parm contains either system or public
Boolean Parser::parseExternalId(const AllowedParams &sysidAllow,
const AllowedParams &endAllow,
Boolean maybeWarnMissingSystemId,
unsigned declInputLevel,
Param &parm,
ExternalId &id)
{
id.setLocation(currentLocation());
if (parm.type == Param::reservedName + Syntax::rPUBLIC) {
static AllowedParams allowMinimumLiteral(Param::minimumLiteral);
if (!parseParam(allowMinimumLiteral, declInputLevel, parm))
return 0;
const MessageType1 *fpierr;
const MessageType1 *urnerr;
switch (id.setPublic(parm.literalText, sd().internalCharset(),
syntax().space(), fpierr, urnerr)) {
case PublicId::fpi:
{
PublicId::TextClass textClass;
if (sd().formal() && id.publicId()->getTextClass(textClass) && textClass == PublicId::SD)
message(ParserMessages::wwwRequired);
if (sd().urn() && !sd().formal())
message(*urnerr, StringMessageArg(*id.publicIdString()));
}
break;
case PublicId::urn:
if (sd().formal() && !sd().urn())
message(*fpierr, StringMessageArg(*id.publicIdString()));
break;
case PublicId::informal:
if (sd().formal())
message(*fpierr, StringMessageArg(*id.publicIdString()));
if (sd().urn())
message(*urnerr, StringMessageArg(*id.publicIdString()));
break;
}
}
if (!parseParam(sysidAllow, declInputLevel, parm))
return 0;
if (parm.type == Param::systemIdentifier) {
id.setSystem(parm.literalText);
if (!parseParam(endAllow, declInputLevel, parm))
return 0;
}
else if (options().warnMissingSystemId && maybeWarnMissingSystemId)
message(ParserMessages::missingSystemId);
return 1;
}
Boolean Parser::parseNotationDecl()
{
unsigned declInputLevel = inputLevel();
Param parm;
if (!parseParam(allowName, declInputLevel, parm))
return 0;
Notation *nt = lookupCreateNotation(parm.token);
if (validate() && nt->defined())
message(ParserMessages::duplicateNotationDeclaration,
StringMessageArg(parm.token));
AttributeDefinitionList *atts = nt->attributeDef().pointer();
if (atts)
for (size_t i = 0; i < atts->size(); i++) {
Boolean implicit;
if (atts->def(i)->isSpecified(implicit) && implicit) {
message(ParserMessages::notationMustNotBeDeclared,
StringMessageArg(parm.token));
break;
}
}
static AllowedParams
allowPublicSystem(Param::reservedName + Syntax::rPUBLIC,
Param::reservedName + Syntax::rSYSTEM);
if (!parseParam(allowPublicSystem, declInputLevel, parm))
return 0;
static AllowedParams allowSystemIdentifierMdc(Param::systemIdentifier,
Param::mdc);
ExternalId id;
if (!parseExternalId(allowSystemIdentifierMdc, allowMdc,
parm.type == Param::reservedName + Syntax::rSYSTEM,
declInputLevel, parm, id))
return 0;
if (validate() && sd().formal()) {
PublicId::TextClass textClass;
const PublicId *publicId = id.publicId();
if (publicId
&& publicId->getTextClass(textClass)
&& textClass != PublicId::NOTATION)
message(ParserMessages::notationIdentifierTextClass);
}
if (!nt->defined()) {
nt->setExternalId(id, markupLocation());
nt->generateSystemId(*this);
if (currentMarkup())
eventHandler().notationDecl(new (eventAllocator())
NotationDeclEvent(nt, markupLocation(),
currentMarkup()));
}
return 1;
}
Boolean Parser::parseEntityDecl()
{
unsigned declInputLevel = inputLevel();
Param parm;
static AllowedParams
allowEntityNamePero(Param::entityName,
Param::indicatedReservedName + Syntax::rDEFAULT,
Param::pero);
if (!parseParam(allowEntityNamePero, declInputLevel, parm))
return 0;
Entity::DeclType declType;
StringC name; // empty for default entity
if (parm.type == Param::pero) {
declType = Entity::parameterEntity;
static AllowedParams allowParamEntityName(Param::paramEntityName);
if (!parseParam(allowParamEntityName, declInputLevel, parm))
return 0;
parm.token.swap(name);
}
else {
declType = Entity::generalEntity;
if (parm.type == Param::entityName)
parm.token.swap(name);
else if (sd().implydefEntity())
message(ParserMessages::implydefEntityDefault);
else if (options().warnDefaultEntityDecl)
message(ParserMessages::defaultEntityDecl);
}
static AllowedParams
allowEntityTextType(Param::paramLiteral,
Param::reservedName + Syntax::rCDATA,
Param::reservedName + Syntax::rSDATA,
Param::reservedName + Syntax::rPI,
Param::reservedName + Syntax::rSTARTTAG,
Param::reservedName + Syntax::rENDTAG,
Param::reservedName + Syntax::rMS,
Param::reservedName + Syntax::rMD,
Param::reservedName + Syntax::rSYSTEM,
Param::reservedName + Syntax::rPUBLIC);
if (!parseParam(allowEntityTextType, declInputLevel, parm))
return 0;
Location typeLocation(currentLocation());
Entity::DataType dataType = Entity::sgmlText;
InternalTextEntity::Bracketed bracketed = InternalTextEntity::none;
switch (parm.type) {
case Param::reservedName + Syntax::rSYSTEM:
case Param::reservedName + Syntax::rPUBLIC:
return parseExternalEntity(name, declType, declInputLevel, parm);
case Param::reservedName + Syntax::rCDATA:
dataType = Entity::cdata;
if (options().warnInternalCdataEntity)
message(ParserMessages::internalCdataEntity);
break;
case Param::reservedName + Syntax::rSDATA:
dataType = Entity::sdata;
if (options().warnInternalSdataEntity)
message(ParserMessages::internalSdataEntity);
break;
case Param::reservedName + Syntax::rPI:
dataType = Entity::pi;
if (options().warnPiEntity)
message(ParserMessages::piEntity);
break;
case Param::reservedName + Syntax::rSTARTTAG:
bracketed = InternalTextEntity::starttag;
if (options().warnBracketEntity)
message(ParserMessages::bracketEntity);
break;
case Param::reservedName + Syntax::rENDTAG:
bracketed = InternalTextEntity::endtag;
if (options().warnBracketEntity)
message(ParserMessages::bracketEntity);
break;
case Param::reservedName + Syntax::rMS:
bracketed = InternalTextEntity::ms;
if (options().warnBracketEntity)
message(ParserMessages::bracketEntity);
break;
case Param::reservedName + Syntax::rMD:
bracketed = InternalTextEntity::md;
if (options().warnBracketEntity)
message(ParserMessages::bracketEntity);
break;
}
if (parm.type != Param::paramLiteral) {
if (!parseParam(allowParamLiteral, declInputLevel, parm))
return 0;
}
Text text;
parm.literalText.swap(text);
if (bracketed != InternalTextEntity::none) {
StringC open;
StringC close;
switch (bracketed) {
case InternalTextEntity::starttag:
open = instanceSyntax().delimGeneral(Syntax::dSTAGO);
close = instanceSyntax().delimGeneral(Syntax::dTAGC);
break;
case InternalTextEntity::endtag:
open = instanceSyntax().delimGeneral(Syntax::dETAGO);
close = instanceSyntax().delimGeneral(Syntax::dTAGC);
break;
case InternalTextEntity::ms: {
const Syntax &syn =
(declType == Entity::parameterEntity) ? syntax() : instanceSyntax();
open = syn.delimGeneral(Syntax::dMDO);
open += syn.delimGeneral(Syntax::dDSO);
close = syn.delimGeneral(Syntax::dMSC);
close += syn.delimGeneral(Syntax::dMDC);
break;
}
case InternalTextEntity::md: {
const Syntax &syn =
(declType == Entity::parameterEntity) ? syntax() : instanceSyntax();
open = syn.delimGeneral(Syntax::dMDO);
close = syn.delimGeneral(Syntax::dMDC);
break;
}
default:
CANNOT_HAPPEN();
}
text.insertChars(open, Location(new BracketOrigin(typeLocation,
BracketOrigin::open),
0));
text.addChars(close, Location(new BracketOrigin(typeLocation,
BracketOrigin::close),
0));
if (text.size() > syntax().litlen()
&& text.size() - open.size() - close.size() <= syntax().litlen())
message(ParserMessages::bracketedLitlen,
NumberMessageArg(syntax().litlen()));
}
if (!parseParam(allowMdc, declInputLevel, parm))
return 0;
if (declType == Entity::parameterEntity
&& (dataType == Entity::cdata || dataType == Entity::sdata)) {
message(ParserMessages::internalParameterDataEntity,
StringMessageArg(name));
return 1;
}
Ptr<Entity> entity;
switch (dataType) {
case Entity::cdata:
entity = new InternalCdataEntity(name, markupLocation(), text);
break;
case Entity::sdata:
entity = new InternalSdataEntity(name, markupLocation(), text);
break;
case Entity::pi:
entity = new PiEntity(name, declType, markupLocation(), text);
break;
case Entity::sgmlText:
entity = new InternalTextEntity(name, declType, markupLocation(), text, bracketed);
break;
default:
CANNOT_HAPPEN();
break;
}
maybeDefineEntity(entity);
return 1;
}
Boolean Parser::parseExternalEntity(StringC &name,
Entity::DeclType declType,
unsigned declInputLevel,
Param &parm)
{
static AllowedParams
allowSystemIdentifierEntityTypeMdc(Param::systemIdentifier,
Param::reservedName + Syntax::rSUBDOC,
Param::reservedName + Syntax::rCDATA,
Param::reservedName + Syntax::rSDATA,
Param::reservedName + Syntax::rNDATA,
Param::mdc);
static AllowedParams
allowEntityTypeMdc(Param::reservedName + Syntax::rSUBDOC,
Param::reservedName + Syntax::rCDATA,
Param::reservedName + Syntax::rSDATA,
Param::reservedName + Syntax::rNDATA,
Param::mdc);
ExternalId id;
if (!parseExternalId(allowSystemIdentifierEntityTypeMdc, allowEntityTypeMdc,
1, declInputLevel, parm, id))
return 0;
if (parm.type == Param::mdc) {
maybeDefineEntity(new ExternalTextEntity(name, declType, markupLocation(),
id));
return 1;
}
Ptr<Entity> entity;
if (parm.type == Param::reservedName + Syntax::rSUBDOC) {
if (sd().subdoc() == 0)
message(ParserMessages::subdocEntity, StringMessageArg(name));
if (!parseParam(allowMdc, declInputLevel, parm))
return 0;
entity = new SubdocEntity(name, markupLocation(), id);
}
else {
Entity::DataType dataType;
switch (parm.type) {
case Param::reservedName + Syntax::rCDATA:
dataType = Entity::cdata;
if (options().warnExternalCdataEntity)
message(ParserMessages::externalCdataEntity);
break;
case Param::reservedName + Syntax::rSDATA:
dataType = Entity::sdata;
if (options().warnExternalSdataEntity)
message(ParserMessages::externalSdataEntity);
break;
case Param::reservedName + Syntax::rNDATA:
dataType = Entity::ndata;
break;
default:
CANNOT_HAPPEN();
}
if (!parseParam(allowName, declInputLevel, parm))
return 0;
Ptr<Notation> notation(lookupCreateNotation(parm.token));
if (!parseParam(allowDsoMdc, declInputLevel, parm))
return 0;
AttributeList attributes(notation->attributeDef());
if (parm.type == Param::dso) {
if (attributes.size() == 0 && !sd().www())
message(ParserMessages::notationNoAttributes,
StringMessageArg(notation->name()));
Boolean netEnabling;
Ptr<AttributeDefinitionList> newAttDef;
if (!parseAttributeSpec(asMode, attributes, netEnabling, newAttDef))
return 0;
if (!newAttDef.isNull()) {
newAttDef->setIndex(defDtd().allocAttributeDefinitionListIndex());
notation->setAttributeDef(newAttDef);
}
if (attributes.nSpec() == 0)
message(ParserMessages::emptyDataAttributeSpec);
if (!parseParam(allowMdc, declInputLevel, parm))
return 0;
}
else
attributes.finish(*this);
entity = new ExternalDataEntity(name, dataType, markupLocation(), id,
notation, attributes,
declType == Entity::parameterEntity
? Entity::parameterEntity
: Entity::generalEntity);
}
if (declType == Entity::parameterEntity && !sd().www()) {
message(ParserMessages::externalParameterDataSubdocEntity,
StringMessageArg(name));
return 1;
}
maybeDefineEntity(entity);
return 1;
}
Notation *Parser::lookupCreateNotation(const StringC &name)
{
Ptr<Notation> nt = defDtd().lookupNotation(name);
if (nt.isNull()) {
nt = new Notation(name, defDtd().namePointer(), defDtd().isBase());
defDtd().insertNotation(nt);
}
return nt.pointer();
}
void Parser::maybeDefineEntity(const Ptr<Entity> &entity)
{
Dtd &dtd = defDtd();
if (haveDefLpd())
entity->setDeclIn(dtd.namePointer(),
dtd.isBase(),
defLpd().namePointer(),
defLpd().active());
else
entity->setDeclIn(dtd.namePointer(), dtd.isBase());
Boolean ignored = 0;
if (entity->name().size() == 0) {
const Entity *oldEntity = dtd.defaultEntity().pointer();
if (oldEntity == 0
|| (!oldEntity->declInActiveLpd() && entity->declInActiveLpd()))
dtd.setDefaultEntity(entity, *this);
else {
ignored = 1;
if (options().warnDuplicateEntity)
message(ParserMessages::duplicateEntityDeclaration,
StringMessageArg(syntax().rniReservedName(Syntax::rDEFAULT)));
}
}
else {
Ptr<Entity> oldEntity = dtd.insertEntity(entity);
if (oldEntity.isNull())
entity->generateSystemId(*this);
else if (oldEntity->defaulted()) {
dtd.insertEntity(entity, 1);
message(ParserMessages::defaultedEntityDefined,
StringMessageArg(entity->name()));
entity->generateSystemId(*this);
}
else {
if (entity->declInActiveLpd() && !oldEntity->declInActiveLpd()) {
dtd.insertEntity(entity, 1);
entity->generateSystemId(*this);
}
else {
ignored = 1;
if (options().warnDuplicateEntity)
message(entity->declType() == Entity::parameterEntity
? ParserMessages::duplicateParameterEntityDeclaration
: ParserMessages::duplicateEntityDeclaration,
StringMessageArg(entity->name()));
}
}
}
if (currentMarkup())
eventHandler().entityDecl(new (eventAllocator())
EntityDeclEvent(entity, ignored,
markupLocation(),
currentMarkup()));
}
Boolean Parser::parseShortrefDecl()
{
if (!defDtd().isBase())
message(ParserMessages::shortrefOnlyInBaseDtd);
unsigned declInputLevel = inputLevel();
Param parm;
if (!parseParam(allowName, declInputLevel, parm))
return 0;
ShortReferenceMap *map = lookupCreateMap(parm.token);
int valid = 1;
if (map->defined()) {
message(ParserMessages::duplicateShortrefDeclaration,
StringMessageArg(parm.token),
map->defLocation());
valid = 0;
}
else
map->setDefLocation(markupLocation());
if (!parseParam(allowParamLiteral, declInputLevel, parm))
return 0;
Vector<StringC> vec;
do {
StringC delim(parm.literalText.string());
instanceSyntax().generalSubstTable()->subst(delim);
size_t srIndex;
if (!defDtd().shortrefIndex(delim, instanceSyntax(), srIndex)) {
message(ParserMessages::unknownShortrefDelim,
StringMessageArg(prettifyDelim(delim)));
valid = 0;
}
static AllowedParams allowEntityName(Param::entityName);
if (!parseParam(allowEntityName, declInputLevel, parm))
return 0;
if (valid) {
if (srIndex >= vec.size())
vec.resize(srIndex + 1);
if (vec[srIndex].size() > 0) {
message(ParserMessages::delimDuplicateMap,
StringMessageArg(prettifyDelim(delim)));
valid = 0;
}
else
parm.token.swap(vec[srIndex]);
}
static AllowedParams allowParamLiteralMdc(Param::paramLiteral, Param::mdc);
if (!parseParam(allowParamLiteralMdc, declInputLevel, parm))
return 0;
} while (parm.type != Param::mdc);
if (valid) {
map->setNameMap(vec);
if (currentMarkup())
eventHandler().shortrefDecl(new (eventAllocator())
ShortrefDeclEvent(map,
currentDtdPointer(),
markupLocation(),
currentMarkup()));
}
return 1;
}
StringC Parser::prettifyDelim(const StringC &delim)
{
StringC prettyDelim;
for (size_t i = 0; i < delim.size(); i++) {
const StringC *nameP;
if (syntax().charFunctionName(delim[i], nameP)) {
prettyDelim += syntax().delimGeneral(Syntax::dCRO);
prettyDelim += *nameP;
prettyDelim += syntax().delimGeneral(Syntax::dREFC);
}
else
prettyDelim += delim[i];
}
return prettyDelim;
}
ShortReferenceMap *Parser::lookupCreateMap(const StringC &name)
{
ShortReferenceMap *map = defDtd().lookupShortReferenceMap(name);
if (!map) {
map = new ShortReferenceMap(name);
defDtd().insertShortReferenceMap(map);
}
return map;
}
Boolean Parser::parseUsemapDecl()
{
if (!inInstance() && !defDtd().isBase())
message(ParserMessages::usemapOnlyInBaseDtd);
unsigned declInputLevel = inputLevel();
Param parm;
static AllowedParams
allowNameEmpty(Param::name,
Param::indicatedReservedName + Syntax::rEMPTY);
if (!parseParam(allowNameEmpty, declInputLevel, parm))
return 0;
const ShortReferenceMap *map;
if (parm.type == Param::name) {
if (inInstance()) {
map = currentDtd().lookupShortReferenceMap(parm.token);
if (!map)
message(ParserMessages::undefinedShortrefMapInstance,
StringMessageArg(parm.token));
}
else {
ShortReferenceMap *tem = lookupCreateMap(parm.token);
tem->setUsed();
map = tem;
}
}
else
map = &theEmptyMap;
static AllowedParams
allowNameNameGroupMdc(Param::name, Param::nameGroup, Param::mdc);
if (!parseParam(allowNameNameGroupMdc, declInputLevel, parm))
return 0;
if (parm.type != Param::mdc) {
if (inInstance()) {
message(ParserMessages::usemapAssociatedElementTypeInstance);
if (!parseParam(allowMdc, declInputLevel, parm))
return 0;
}
else {
Vector<const ElementType *> v;
if (parm.type == Param::name) {
ElementType *e = lookupCreateElement(parm.token);
v.push_back(e);
if (!e->map())
e->setMap(map);
}
else {
v.resize(parm.nameTokenVector.size());
for (size_t i = 0; i < parm.nameTokenVector.size(); i++) {
ElementType *e
= lookupCreateElement(parm.nameTokenVector[i].name);
v[i] = e;
if (!e->map())
e->setMap(map);
}
}
if (!parseParam(allowMdc, declInputLevel, parm))
return 0;
if (currentMarkup())
eventHandler().usemap(new (eventAllocator())
UsemapEvent(map, v,
currentDtdPointer(),
markupLocation(),
currentMarkup()));
}
}
else {
if (!inInstance())
message(ParserMessages::usemapAssociatedElementTypeDtd);
else if (map) {
if (map != &theEmptyMap && !map->defined())
message(ParserMessages::undefinedShortrefMapInstance,
StringMessageArg(map->name()));
else {
if (currentMarkup()) {
Vector<const ElementType *> v;
eventHandler().usemap(new (eventAllocator())
UsemapEvent(map, v,
currentDtdPointer(),
markupLocation(),
currentMarkup()));
}
currentElement().setMap(map);
}
}
}
return 1;
}
Boolean Parser::parseDoctypeDeclStart()
{
if (hadDtd() && !sd().concur() && !sd().explicitLink())
message(ParserMessages::multipleDtds);
if (hadLpd())
message(ParserMessages::dtdAfterLpd);
unsigned declInputLevel = inputLevel();
Param parm;
static AllowedParams
allowImpliedName(Param::indicatedReservedName + Syntax::rIMPLIED,
Param::name);
if (!parseParam(sd().www() ? allowImpliedName : allowName, declInputLevel, parm))
return 0;
if (parm.type == Param::indicatedReservedName + Syntax::rIMPLIED) {
if (sd().concur() > 0 || sd().explicitLink() > 0)
message(ParserMessages::impliedDoctypeConcurLink);
message(ParserMessages::sorryImpliedDoctype);
return 0;
}
StringC name;
parm.token.swap(name);
if (!lookupDtd(name).isNull())
message(ParserMessages::duplicateDtd, StringMessageArg(name));
static AllowedParams
allowPublicSystemDsoMdc(Param::reservedName + Syntax::rPUBLIC,
Param::reservedName + Syntax::rSYSTEM,
Param::dso,
Param::mdc);
if (!parseParam(allowPublicSystemDsoMdc, declInputLevel, parm))
return 0;
ConstPtr<Entity> entity;
StringC notation;
EntityDecl::DataType data;
ExternalId id;
if (parm.type == Param::reservedName + Syntax::rPUBLIC
|| parm.type == Param::reservedName + Syntax::rSYSTEM) {
static AllowedParams allowSystemIdentifierDsoMdc(Param::systemIdentifier,
Param::dso, Param::mdc);
static AllowedParams
allowSystemIdentifierDsoMdcData(Param::systemIdentifier,
Param::dso, Param::mdc,
Param::reservedName + Syntax::rCDATA,
Param::reservedName + Syntax::rSDATA,
Param::reservedName + Syntax::rNDATA);
static AllowedParams allowDsoMdcData(Param::dso, Param::mdc,
Param::reservedName + Syntax::rCDATA,
Param::reservedName + Syntax::rSDATA,
Param::reservedName + Syntax::rNDATA);
if (!parseExternalId(sd().www() ? allowSystemIdentifierDsoMdcData :
allowSystemIdentifierDsoMdc,
sd().www() ? allowDsoMdcData : allowDsoMdc,
1, declInputLevel, parm, id))
return 0;
switch (parm.type) {
case Param::reservedName + Syntax::rCDATA:
data = Entity::cdata;
break;
case Param::reservedName + Syntax::rSDATA:
data = Entity::sdata;
break;
case Param::reservedName + Syntax::rNDATA:
data = Entity::ndata;
break;
default:
data = Entity::sgmlText;
break;
}
if (data == Entity::sgmlText) {
Ptr<Entity> tem
= new ExternalTextEntity(name, Entity::doctype, markupLocation(), id);
tem->generateSystemId(*this);
entity = tem;
}
#if 0
eventHandler()
.externalEntityDecl(new (eventAllocator())
ExternalEntityDeclEvent(entity, 0));
#endif
else {
// external subset uses some DTD notation
if (!parseParam(allowName, declInputLevel, parm))
return 0;
parm.token.swap(notation);
if (!parseParam(allowDsoMdc, declInputLevel, parm))
return 0;
}
}
else
// no external subset specified
if (sd().implydefDoctype()) {
// FIXME this fails for #IMPLIED, since name isn't yet known
Ptr<Entity> tem
= new ExternalTextEntity(name, Entity::doctype, markupLocation(), id);
tem->generateSystemId(*this);
entity = tem;
}
else if (parm.type == Param::mdc) {
if (sd().implydefElement() == Sd::implydefElementNo) {
message(ParserMessages::noDtdSubset);
enableImplydef();
}
}
// Discard mdc or dso
if (currentMarkup())
currentMarkup()->resize(currentMarkup()->size() - 1);
eventHandler().startDtd(new (eventAllocator())
StartDtdEvent(name, entity, parm.type == Param::dso,
markupLocation(),
currentMarkup()));
startDtd(name);
if (notation.size() > 0) {
// FIXME this case has the wrong entity in the event
// this should be fixed by moving startDtd() call and this code up
ConstPtr<Notation> nt(lookupCreateNotation(notation));
AttributeList attrs(nt->attributeDef());
attrs.finish(*this);
Ptr<Entity> tem
= new ExternalDataEntity(name, data, markupLocation(), id, nt, attrs,
Entity::doctype);
tem->generateSystemId(*this);
// FIXME This is a hack; we need the entity to have the doctype name to
// have generateSytemId() work properly, but have an empty name to add
// it as a parameter entity, which is needed to check the notation
StringC entname;
tem->setName(entname);
defDtd().insertEntity(tem);
entity = tem;
}
if (parm.type == Param::mdc) {
// unget the mdc
currentInput()->ungetToken();
if (entity.isNull()) {
(void)parseDoctypeDeclEnd();
return 1;
}
// reference the entity
Ptr<EntityOrigin> origin
= EntityOrigin::make(internalAllocator(), entity, currentLocation());
entity->dsReference(*this, origin);
if (inputLevel() == 1) { // reference failed
(void)parseDoctypeDeclEnd();
return 1;
}
}
else if (!entity.isNull())
setDsEntity(entity);
setPhase(declSubsetPhase);
return 1;
}
void Parser::implyDtd(const StringC &gi)
{
startMarkup(eventsWanted().wantPrologMarkup(), currentLocation());
#if 0
if (currentMarkup()) {
currentMarkup()->addDelim(Syntax::dMDO);
currentMarkup()->addReservedName(Syntax::rDOCTYPE,
syntax().reservedName(Syntax::rDOCTYPE));
currentMarkup()->addS(syntax().space());
currentMarkup()->addName(gi.data(), gi.size());
}
#endif
if (sd().concur() > 0 || sd().explicitLink() > 0
|| (sd().implydefElement() == Sd::implydefElementNo
&& !sd().implydefDoctype()))
message(ParserMessages::omittedProlog);
if ((sd().implydefElement() != Sd::implydefElementNo) && !sd().implydefDoctype()) {
eventHandler().startDtd(new (eventAllocator())
StartDtdEvent(gi, ConstPtr<Entity>(), 0,
markupLocation(),
currentMarkup()));
startDtd(gi);
parseDoctypeDeclEnd(1);
return;
}
ExternalId id;
// The null location indicates that this is a fake entity.
Entity *tem = new ExternalTextEntity(gi, Entity::doctype, Location(), id);
ConstPtr<Entity> entity(tem);
if (sd().implydefDoctype())
tem->generateSystemId(*this);
else {
// Don't use Entity::generateSystemId because we don't want an error
// if it fails.
StringC str;
if (!entityCatalog().lookup(*entity, syntax(), sd().internalCharset(),
messenger(), str)) {
message(ParserMessages::noDtd);
enableImplydef();
eventHandler().startDtd(new (eventAllocator())
StartDtdEvent(gi, ConstPtr<Entity>(), 0,
markupLocation(),
currentMarkup()));
startDtd(gi);
parseDoctypeDeclEnd(1);
return;
}
id.setEffectiveSystem(str);
#if 0
if (currentMarkup()) {
currentMarkup()->addS(syntax().space());
currentMarkup()->addReservedName(Syntax::rSYSTEM,
syntax().reservedName(Syntax::rSYSTEM));
}
#endif
entity = new ExternalTextEntity(gi,
Entity::doctype,
Location(),
id);
StringC declStr;
declStr += syntax().delimGeneral(Syntax::dMDO);
declStr += syntax().reservedName(Syntax::rDOCTYPE);
declStr += syntax().space();
declStr += gi;
declStr += syntax().space();
declStr += syntax().reservedName(Syntax::rSYSTEM);
declStr += syntax().delimGeneral(Syntax::dMDC);
message(ParserMessages::implyingDtd, StringMessageArg(declStr));
}
Ptr<EntityOrigin> origin
= EntityOrigin::make(internalAllocator(), entity, currentLocation());
eventHandler().startDtd(new (eventAllocator())
StartDtdEvent(gi, entity, 0,
markupLocation(),
currentMarkup()));
startDtd(gi);
entity->dsReference(*this, origin);
if (inputLevel() == 1)
parseDoctypeDeclEnd(1);
else
setPhase(declSubsetPhase);
}
Boolean Parser::parseDoctypeDeclEnd(Boolean fake)
{
checkDtd(defDtd());
Ptr<Dtd> tem(defDtdPointer());
endDtd();
if (fake) {
startMarkup(eventsWanted().wantPrologMarkup(), currentLocation());
#if 0
if (currentMarkup())
currentMarkup()->addDelim(Syntax::dMDC);
#endif
}
else {
startMarkup(eventsWanted().wantPrologMarkup(), currentLocation());
Param parm;
// End DTD before parsing final param so parameter entity reference
// not allowed between ] and >.
if (!parseParam(allowMdc, inputLevel(), parm))
return 0;
}
eventHandler().endDtd(new (eventAllocator()) EndDtdEvent(tem,
markupLocation(),
currentMarkup()));
#if 0
if (fake) {
Char c = syntax().standardFunction(Syntax::fRE);
eventHandler().sSep(new (eventAllocator())
SSepEvent(&c, 1, Location(), 1));
}
#endif
return 1;
}
void Parser::checkDtd(Dtd &dtd)
{
if (dtd.isBase())
addNeededShortrefs(dtd, instanceSyntax());
if (sd().www() || !options().errorAfdr)
addCommonAttributes(dtd);
Dtd::ElementTypeIter elementIter(dtd.elementTypeIter());
ElementType *p;
ConstPtr<ElementDefinition> def;
int i = 0;
while ((p = elementIter.next()) != 0) {
if (p->definition() == 0) {
if (p->name() == dtd.name()) {
if (validate() && (implydefElement() == Sd::implydefElementNo))
message(ParserMessages::documentElementUndefined);
}
else if (options().warnUndefinedElement)
message(ParserMessages::dtdUndefinedElement, StringMessageArg(p->name()));
if (def.isNull())
def = new ElementDefinition(currentLocation(),
size_t(ElementDefinition::undefinedIndex),
ElementDefinition::omitEnd,
ElementDefinition::any,
(implydefElement() != Sd::implydefElementAnyother));
p->setElementDefinition(def, i++);
}
const ShortReferenceMap *map = p->map();
if (map != 0 && map != &theEmptyMap && !map->defined()) {
if (validate())
message(ParserMessages::undefinedShortrefMapDtd,
StringMessageArg(map->name()),
StringMessageArg(p->name()));
p->setMap(0);
}
}
Dtd::ShortReferenceMapIter mapIter(dtd.shortReferenceMapIter());
int nShortref = dtd.nShortref();
for (;;) {
ShortReferenceMap *map = mapIter.next();
if (!map)
break;
Vector<ConstPtr<Entity> > entityMap(nShortref);
for (i = 0; i < nShortref; i++) {
const StringC *entityName = map->entityName(i);
if (entityName) {
ConstPtr<Entity> entity
= lookupEntity(0, *entityName, map->defLocation(), 0);
if (entity.isNull()) {
setNextLocation(map->defLocation());
message(ParserMessages::mapEntityUndefined,
StringMessageArg(*entityName),
StringMessageArg(map->name()));
}
else {
if (entity->defaulted() && options().warnDefaultEntityReference) {
setNextLocation(map->defLocation());
message(ParserMessages::mapDefaultEntity,
StringMessageArg(*entityName),
StringMessageArg(map->name()));
}
entityMap[i] = entity;
}
}
}
map->setEntityMap(entityMap);
if (options().warnUnusedMap && !map->used()) {
setNextLocation(map->defLocation());
message(ParserMessages::unusedMap, StringMessageArg(map->name()));
}
}
if (options().warnUnusedParam) {
Dtd::ConstEntityIter entityIter(((const Dtd &)dtd).parameterEntityIter());
for (;;) {
ConstPtr<Entity> entity(entityIter.next());
if (entity.isNull())
break;
if (!entity->used() && !maybeStatusKeyword(*entity)) {
setNextLocation(entity->defLocation());
message(ParserMessages::unusedParamEntity,
StringMessageArg(entity->name()));
}
}
}
Dtd::ConstEntityIter gEntityIter(((const Dtd &)dtd).generalEntityIter());
Dtd::ConstEntityIter pEntityIter(((const Dtd &)dtd).parameterEntityIter());
for (i = 0; i < (sd().www() ? 2 : 1); i++) {
for (;;) {
ConstPtr<Entity> entity(i == 0 ? gEntityIter.next() : pEntityIter.next());
if (entity.isNull())
break;
const ExternalDataEntity *external = entity->asExternalDataEntity();
if (external) {
Notation *notation = (Notation *)external->notation();
if (!notation->defined()) {
if (sd().implydefNotation()) {
ExternalId id;
notation->setExternalId(id, Location());
notation->generateSystemId(*this);
}
else if (validate()) {
setNextLocation(external->defLocation());
switch (external->declType()) {
case Entity::parameterEntity:
message(ParserMessages::parameterEntityNotationUndefined,
StringMessageArg(notation->name()),
StringMessageArg(external->name()));
break;
case Entity::doctype:
message(ParserMessages::dsEntityNotationUndefined,
StringMessageArg(notation->name()));
break;
default:
message(ParserMessages::entityNotationUndefined,
StringMessageArg(notation->name()),
StringMessageArg(external->name()));
break;
}
}
}
}
}
}
Dtd::NotationIter notationIter(dtd.notationIter());
for (;;) {
Ptr<Notation> notation(notationIter.next());
if (notation.isNull())
break;
if (!notation->defined() && !notation->attributeDef().isNull()) {
if (sd().implydefNotation()) {
ExternalId id;
notation->setExternalId(id, Location());
notation->generateSystemId(*this);
}
else if (validate())
message(ParserMessages::attlistNotationUndefined,
StringMessageArg(notation->name()));
}
}
}
#if 0
void Parser::addCommonAttributes(Dtd &dtd)
{
Ptr<AttributeDefinitionList> commonAdl[2];
{
ElementType *e = dtd.removeElementType(syntax()
.rniReservedName(Syntax::rALL));
if (e) {
commonAdl[0] = e->attributeDef();
delete e;
lookupCreateElement(syntax().rniReservedName(Syntax::rIMPLICIT));
}
}
{
Ptr<Notation> allNotation
= dtd.removeNotation(syntax().rniReservedName(Syntax::rALL));
if (!allNotation.isNull()) {
commonAdl[1] = allNotation->attributeDef();
lookupCreateNotation(syntax().rniReservedName(Syntax::rIMPLICIT));
}
}
Dtd::ElementTypeIter elementIter(dtd.elementTypeIter());
Dtd::NotationIter notationIter(dtd.notationIter());
Vector<PackedBoolean> doneAdl(dtd.nAttributeDefinitionList(),
PackedBoolean(0));
for (int isNotation = 0; isNotation < 2; isNotation++) {
if (!commonAdl[isNotation].isNull()) {
doneAdl[commonAdl[isNotation]->index()] = 1;
for (;;) {
Attributed *a;
if (!isNotation)
a = elementIter.next();
else
a = notationIter.next().pointer();
if (!a)
break;
Ptr<AttributeDefinitionList> adl = a->attributeDef();
if (adl.isNull())
a->setAttributeDef(commonAdl[isNotation]);
else if (!doneAdl[adl->index()]) {
doneAdl[adl->index()] = 1;
for (size_t j = 0; j < commonAdl[isNotation]->size(); j++) {
unsigned tem;
if (!adl->attributeIndex(commonAdl[isNotation]->def(j)->name(),
tem))
adl->append(commonAdl[isNotation]->def(j)->copy());
}
}
}
}
}
{
ElementType *e = dtd.removeElementType(syntax()
.rniReservedName(Syntax::rIMPLICIT));
if (e)
dtd.setImplicitElementAttributeDef(e->attributeDef());
delete e;
}
{
Ptr<Notation> n
= dtd.removeNotation(syntax().rniReservedName(Syntax::rIMPLICIT));
if (!n.isNull())
dtd.setImplicitNotationAttributeDef(n->attributeDef());
}
}
#else
void Parser::addCommonAttributes(Dtd &dtd)
{
// These are #implicit, #all, #notation #implicit, #notation #all
Ptr<AttributeDefinitionList> commonAdl[4];
{
ElementType *e = lookupCreateElement(syntax()
.rniReservedName(Syntax::rIMPLICIT));
commonAdl[0] = e->attributeDef();
e = dtd.removeElementType(syntax().rniReservedName(Syntax::rALL));
if (e)
commonAdl[1] = e->attributeDef();
delete e;
}
{
Ptr<Notation> nt
= lookupCreateNotation(syntax().rniReservedName(Syntax::rIMPLICIT));
commonAdl[2] = nt->attributeDef();
nt = dtd.removeNotation(syntax().rniReservedName(Syntax::rALL));
if (!nt.isNull())
commonAdl[3] = nt->attributeDef();
}
Dtd::ElementTypeIter elementIter(dtd.elementTypeIter());
Dtd::ElementTypeIter element2Iter(dtd.elementTypeIter());
Dtd::NotationIter notationIter(dtd.notationIter());
Dtd::NotationIter notation2Iter(dtd.notationIter());
Vector<PackedBoolean> done1Adl(dtd.nAttributeDefinitionList(),
PackedBoolean(0));
Vector<PackedBoolean> done2Adl(dtd.nAttributeDefinitionList(),
PackedBoolean(0));
// we do 2 passes over element types and notations,
// first merging #implicit attributes for implicit element types/notations
// next merging #all attributes for all element types/notations
for (int i = 0; i < 4; i++) {
if (!commonAdl[i].isNull()) {
if (i % 2)
done1Adl[commonAdl[i]->index()] = 1;
else
done2Adl[commonAdl[i]->index()] = 1;
for (;;) {
Boolean skip;
Attributed *a;
switch (i) {
case 0:
{
ElementType *e = elementIter.next();
a = e;
skip = (e && e->definition()); // don't merge #implicit
// attributes if e is defined
}
break;
case 1:
a = element2Iter.next();
skip = 0; // always merge #all attributes
break;
case 2:
{
Notation *nt = notationIter.next().pointer();
a = nt;
skip = (nt && nt->defined()); // don't merge #implicit
// attributes if nt is defined
}
break;
case 3:
a = notation2Iter.next().pointer();
skip = 0; // always merge #all attributes
break;
default:
CANNOT_HAPPEN();
}
if (!a)
break;
Ptr<AttributeDefinitionList> adl = a->attributeDef();
if (adl.isNull()) {
if (!skip)
a->setAttributeDef(commonAdl[i]);
}
else if (((i % 2) && !done1Adl[adl->index()])
||(!(i % 2) && !done2Adl[adl->index()])) {
if (i % 2)
done1Adl[adl->index()] = 1;
else
done2Adl[adl->index()] = 1;
if (!skip)
for (size_t j = 0; j < commonAdl[i]->size(); j++) {
unsigned index;
if (!adl->attributeIndex(commonAdl[i]->def(j)->name(),
index))
adl->append(commonAdl[i]->def(j)->copy());
else if (i == 2) {
// Give an error if an #ALL data attribute was
// specified and is later redeclared as #IMPLICIT
Boolean implicit;
if (adl->def(index)->isSpecified(implicit) && !implicit)
message(ParserMessages::specifiedAttributeRedeclared,
StringMessageArg(adl->def(index)->name()));
}
}
}
}
}
}
{
ElementType *e = dtd.removeElementType(syntax()
.rniReservedName(Syntax::rIMPLICIT));
if (e)
dtd.setImplicitElementAttributeDef(e->attributeDef());
delete e;
}
{
Ptr<Notation> n
= dtd.removeNotation(syntax().rniReservedName(Syntax::rIMPLICIT));
if (!n.isNull())
dtd.setImplicitNotationAttributeDef(n->attributeDef());
}
}
#endif
Boolean Parser::maybeStatusKeyword(const Entity &entity)
{
const InternalEntity *internal = entity.asInternalEntity();
if (!internal)
return 0;
const StringC &text = internal->string();
static const Syntax::ReservedName statusKeywords[] = {
Syntax::rINCLUDE, Syntax::rIGNORE
};
for (size_t i = 0; i < SIZEOF(statusKeywords); i++) {
const StringC &keyword = instanceSyntax().reservedName(statusKeywords[i]);
size_t j = 0;
while (j < text.size() && instanceSyntax().isS(text[j]))
j++;
size_t k = 0;
while (j < text.size()
&& k < keyword.size()
&& ((*instanceSyntax().generalSubstTable())[text[j]]
== keyword[k]))
j++, k++;
if (k == keyword.size()) {
while (j < text.size() && instanceSyntax().isS(text[j]))
j++;
if (j == text.size())
return 1;
}
}
return 0;
}
Boolean Parser::parseLinktypeDeclStart()
{
if (baseDtd().isNull())
message(ParserMessages::lpdBeforeBaseDtd);
unsigned declInputLevel = inputLevel();
Param parm;
if (!parseParam(allowName, declInputLevel, parm))
return 0;
StringC name;
parm.token.swap(name);
if (!lookupDtd(name).isNull())
message(ParserMessages::duplicateDtdLpd, StringMessageArg(name));
else if (!lookupLpd(name).isNull())
message(ParserMessages::duplicateLpd, StringMessageArg(name));
static AllowedParams
allowSimpleName(Param::indicatedReservedName + Syntax::rSIMPLE,
Param::name);
if (!parseParam(allowSimpleName, declInputLevel, parm))
return 0;
Boolean simple;
Ptr<Dtd> sourceDtd;
if (parm.type == Param::indicatedReservedName + Syntax::rSIMPLE) {
simple = 1;
sourceDtd = baseDtd();
if (sourceDtd.isNull())
sourceDtd = new Dtd(StringC(), 1);
}
else {
simple = 0;
sourceDtd = lookupDtd(parm.token);
if (sourceDtd.isNull()) {
message(ParserMessages::noSuchDtd, StringMessageArg(parm.token));
sourceDtd = new Dtd(parm.token, 0);
}
}
static AllowedParams
allowImpliedName(Param::indicatedReservedName + Syntax::rIMPLIED,
Param::name);
if (!parseParam(allowImpliedName, declInputLevel, parm))
return 0;
Ptr<Dtd> resultDtd;
Boolean implied = 0;
if (parm.type == Param::indicatedReservedName + Syntax::rIMPLIED) {
if (simple) {
if (!sd().simpleLink())
message(ParserMessages::simpleLinkFeature);
}
else {
implied = 1;
if (!sd().implicitLink())
message(ParserMessages::implicitLinkFeature);
}
}
else {
if (simple)
message(ParserMessages::simpleLinkResultNotImplied);
else {
if (!sd().explicitLink())
message(ParserMessages::explicitLinkFeature);
resultDtd = lookupDtd(parm.token);
if (resultDtd.isNull())
message(ParserMessages::noSuchDtd, StringMessageArg(parm.token));
}
}
static AllowedParams
allowPublicSystemDsoMdc(Param::reservedName + Syntax::rPUBLIC,
Param::reservedName + Syntax::rSYSTEM,
Param::dso,
Param::mdc);
if (!parseParam(allowPublicSystemDsoMdc, declInputLevel, parm))
return 0;
ConstPtr<Entity> entity;
if (parm.type == Param::reservedName + Syntax::rPUBLIC
|| parm.type == Param::reservedName + Syntax::rSYSTEM) {
static AllowedParams allowSystemIdentifierDsoMdc(Param::systemIdentifier,
Param::dso, Param::mdc);
ExternalId id;
if (!parseExternalId(allowSystemIdentifierDsoMdc, allowDsoMdc,
1, declInputLevel, parm, id))
return 0;
Ptr<Entity> tem
= new ExternalTextEntity(name, Entity::linktype, markupLocation(), id);
tem->generateSystemId(*this);
entity = tem;
#if 0
eventHandler()
.externalEntityDecl(new (eventAllocator())
ExternalEntityDeclEvent(entity, 0));
#endif
}
Ptr<Lpd> lpd;
if (simple)
lpd = new SimpleLpd(name, markupLocation(), sourceDtd);
else
lpd = new ComplexLpd(name,
implied ? Lpd::implicitLink : Lpd::explicitLink,
markupLocation(),
syntax(),
sourceDtd,
resultDtd);
if (!baseDtd().isNull() && shouldActivateLink(name)) {
size_t nActive = nActiveLink();
if (simple) {
size_t nSimple = 0;
for (size_t i = 0; i < nActive; i++)
if (activeLpd(i).type() == Lpd::simpleLink)
nSimple++;
if (nSimple == sd().simpleLink())
message(ParserMessages::simpleLinkCount,
NumberMessageArg(sd().simpleLink()));
lpd->activate();
}
else {
Boolean haveImplicit = 0;
Boolean haveExplicit = 0;
size_t i;
for (i = 0; i < nActive; i++) {
if (activeLpd(i).type() == Lpd::implicitLink)
haveImplicit = 1;
else if (activeLpd(i).type() == Lpd::explicitLink)
haveExplicit = 1;
}
const Dtd *sourceDtd = lpd->sourceDtd().pointer();
if (implied && haveImplicit)
message(ParserMessages::oneImplicitLink);
else if (sd().explicitLink() <= 1 && sourceDtd != baseDtd().pointer())
message(sd().explicitLink() == 0
? ParserMessages::explicitNoRequiresSourceTypeBase
: ParserMessages::explicit1RequiresSourceTypeBase,
StringMessageArg(lpd->name()));
else if (sd().explicitLink() == 1 && haveExplicit && !implied)
message(ParserMessages::duplicateExplicitChain);
else if (haveExplicit || haveImplicit
|| sourceDtd != baseDtd().pointer())
message(ParserMessages::sorryLink, StringMessageArg(lpd->name()));
else
lpd->activate();
}
}
// Discard mdc or dso
if (currentMarkup())
currentMarkup()->resize(currentMarkup()->size() - 1);
eventHandler().startLpd(new (eventAllocator())
StartLpdEvent(lpd->active(),
name,
entity,
parm.type == Param::dso,
markupLocation(),
currentMarkup()));
startLpd(lpd);
if (parm.type == Param::mdc) {
// unget the mdc
currentInput()->ungetToken();
if (entity.isNull()) {
message(ParserMessages::noLpdSubset, StringMessageArg(name));
(void)parseLinktypeDeclEnd();
return 1;
}
// reference the entity
Ptr<EntityOrigin> origin
= EntityOrigin::make(internalAllocator(), entity, currentLocation());
entity->dsReference(*this, origin);
if (inputLevel() == 1) { // reference failed
(void)parseLinktypeDeclEnd();
return 1;
}
}
else if (!entity.isNull())
setDsEntity(entity);
setPhase(declSubsetPhase);
return 1;
}
Boolean Parser::parseLinktypeDeclEnd()
{
if (defLpd().type() != Lpd::simpleLink) {
if (!defComplexLpd().initialLinkSet()->defined())
message(ParserMessages::noInitialLinkSet,
StringMessageArg(defLpd().name()));
ComplexLpd::ConstLinkSetIter iter = defComplexLpd().linkSetIter();
const LinkSet *linkSet;
while ((linkSet = iter.next()) != 0)
if (!linkSet->defined())
message(ParserMessages::undefinedLinkSet, StringMessageArg(linkSet->name()));
}
ConstPtr<Lpd> tem(defLpdPointer());
endLpd();
startMarkup(eventsWanted().wantPrologMarkup(), currentLocation());
Param parm;
Boolean result = parseParam(allowMdc, inputLevel(), parm);
eventHandler().endLpd(new (eventAllocator()) EndLpdEvent(tem,
markupLocation(),
currentMarkup()));
return result;
}
Boolean Parser::parseLinkDecl()
{
return parseLinkSet(0);
}
Boolean Parser::parseIdlinkDecl()
{
return parseLinkSet(1);
}
// This will only get called if we're defining a complex lpd.
Boolean Parser::parseLinkSet(Boolean idlink)
{
if (defLpd().type() == Lpd::simpleLink) {
message(idlink ? ParserMessages::idlinkDeclSimple : ParserMessages::linkDeclSimple);
return 0;
}
if (idlink) {
if (defComplexLpd().hadIdLinkSet())
message(ParserMessages::duplicateIdLinkSet);
else
defComplexLpd().setHadIdLinkSet();
}
unsigned declInputLevel = inputLevel();
Param parm;
Boolean isExplicit = (defLpd().type() == Lpd::explicitLink);
LinkSet *linkSet;
if (idlink) {
if (!parseParam(allowName, declInputLevel, parm))
return 0;
linkSet = 0;
}
else {
static AllowedParams
allowNameInitial(Param::name,
Param::indicatedReservedName + Syntax::rINITIAL);
if (!parseParam(allowNameInitial, declInputLevel, parm))
return 0;
if (parm.type == Param::name)
linkSet = lookupCreateLinkSet(parm.token);
else
linkSet = defComplexLpd().initialLinkSet();
if (linkSet->defined())
message(ParserMessages::duplicateLinkSet, StringMessageArg(linkSet->name()));
static AllowedParams
allowExplicitLinkRule(Param::name,
Param::nameGroup,
Param::indicatedReservedName + Syntax::rIMPLIED);
if (!parseParam(isExplicit ? allowExplicitLinkRule : allowNameNameGroup,
declInputLevel, parm))
return 0;
}
do {
StringC id;
if (idlink) {
parm.token.swap(id);
if (!parseParam(isExplicit ? allowExplicitLinkRuleMdc : allowNameNameGroupMdc,
declInputLevel, parm))
return 0;
}
if (parm.type == Param::indicatedReservedName + Syntax::rIMPLIED) {
if (!parseParam(allowName, declInputLevel, parm))
return 0;
Boolean resultImplied;
const ElementType *resultType;
AttributeList resultAttributes;
if (!parseResultElementSpec(declInputLevel,
parm,
idlink,
resultImplied,
resultType,
resultAttributes))
return 0;
if (resultType) {
const AttributeList *dummy;
if (linkSet->impliedResultAttributes(resultType, dummy))
message(ParserMessages::duplicateImpliedResult,
StringMessageArg(resultType->name()));
else
linkSet->addImplied(resultType, resultAttributes);
}
}
else {
SourceLinkRule *linkRule = 0;
IdLinkRule idLinkRule;
Ptr<SourceLinkRuleResource> linkRuleResource;
if (idlink)
linkRule = &idLinkRule;
else {
linkRuleResource = new SourceLinkRuleResource;
linkRule = linkRuleResource.pointer();
}
Vector<const ElementType *> assocElementTypes;
if (parm.type == Param::name) {
assocElementTypes.resize(1);
assocElementTypes[0] = lookupCreateElement(parm.token);
}
else {
assocElementTypes.resize(parm.nameTokenVector.size());
for (size_t i = 0; i < assocElementTypes.size(); i++)
assocElementTypes[i]
= lookupCreateElement(parm.nameTokenVector[i].name);
}
static AllowedParams
allow2i(Param::indicatedReservedName + Syntax::rUSELINK,
Param::indicatedReservedName + Syntax::rPOSTLINK,
Param::dso,
Param::mdc,
Param::name,
Param::nameGroup);
static AllowedParams
allow2id(Param::indicatedReservedName + Syntax::rUSELINK,
Param::indicatedReservedName + Syntax::rPOSTLINK,
Param::dso,
Param::mdc,
Param::name);
static AllowedParams
allow2e(Param::indicatedReservedName + Syntax::rUSELINK,
Param::indicatedReservedName + Syntax::rPOSTLINK,
Param::dso,
Param::name,
Param::indicatedReservedName + Syntax::rIMPLIED);
if (!parseParam(isExplicit
? allow2e
: (idlink ? allow2id : allow2i), declInputLevel, parm))
return 0;
if (parm.type == Param::indicatedReservedName + Syntax::rUSELINK) {
static AllowedParams
allowLinkSetEmpty(Param::name,
Param::indicatedReservedName + Syntax::rINITIAL,
Param::indicatedReservedName + Syntax::rEMPTY);
if (!parseParam(allowLinkSetEmpty, declInputLevel, parm))
return 0;
const LinkSet *uselink;
if (parm.type == Param::name)
uselink = lookupCreateLinkSet(parm.token);
else if (parm.type == Param::indicatedReservedName + Syntax::rINITIAL)
uselink = defComplexLpd().initialLinkSet();
else
uselink = defComplexLpd().emptyLinkSet();
linkRule->setUselink(uselink);
static AllowedParams
allow3i(Param::indicatedReservedName + Syntax::rPOSTLINK,
Param::dso,
Param::mdc,
Param::name,
Param::nameGroup);
static AllowedParams
allow3id(Param::indicatedReservedName + Syntax::rPOSTLINK,
Param::dso,
Param::mdc,
Param::name);
static AllowedParams
allow3e(Param::indicatedReservedName + Syntax::rPOSTLINK,
Param::dso,
Param::name,
Param::indicatedReservedName + Syntax::rIMPLIED);
if (!parseParam(isExplicit
? allow3e
: (idlink ? allow3id : allow3i),
declInputLevel, parm))
return 0;
}
if (parm.type == Param::indicatedReservedName + Syntax::rPOSTLINK) {
if (!parseParam(allowLinkSetSpec, declInputLevel, parm))
return 0;
const LinkSet *postlink;
if (parm.type == Param::indicatedReservedName + Syntax::rRESTORE)
linkRule->setPostlinkRestore();
else {
if (parm.type == Param::name)
postlink = lookupCreateLinkSet(parm.token);
else if (parm.type
== Param::indicatedReservedName + Syntax::rINITIAL)
postlink = defComplexLpd().initialLinkSet();
else
postlink = defComplexLpd().emptyLinkSet();
linkRule->setPostlink(postlink);
}
static AllowedParams
allow4i(Param::dso,
Param::mdc,
Param::name,
Param::nameGroup);
static AllowedParams
allow4id(Param::dso,
Param::mdc,
Param::name);
static AllowedParams
allow4e(Param::dso,
Param::name,
Param::indicatedReservedName + Syntax::rIMPLIED);
if (!parseParam(isExplicit
? allow4e
: (idlink ? allow4id : allow4i),
declInputLevel, parm))
return 0;
}
AttributeList attributes;
ConstPtr<AttributeDefinitionList> attDef;
for (size_t i = 0; i < assocElementTypes.size(); i++) {
const ElementType *e = assocElementTypes[i];
if (e) {
if (i == 0)
attDef = defComplexLpd().attributeDef(e);
else if (attDef != defComplexLpd().attributeDef(e))
message(ParserMessages::assocElementDifferentAtts);
// FIXME recover from this
}
}
attributes.init(attDef);
if (parm.type == Param::dso) {
Boolean netEnabling;
Ptr<AttributeDefinitionList> newAttDef;
if (!parseAttributeSpec(asMode, attributes, netEnabling, newAttDef))
return 0;
if (!newAttDef.isNull()) {
newAttDef->setIndex(defComplexLpd().allocAttributeDefinitionListIndex());
for (size_t i = 0; i < assocElementTypes.size(); i++) {
const ElementType *e = assocElementTypes[i];
if (e && defComplexLpd().attributeDef(e) == attDef)
defComplexLpd().setAttributeDef(e, newAttDef);
}
}
static AllowedParams
allow5e(Param::name,
Param::indicatedReservedName + Syntax::rIMPLIED);
if (!parseParam(isExplicit
? allow5e
: (idlink ? allowNameMdc : allowNameNameGroupMdc),
declInputLevel, parm))
return 0;
}
else
attributes.finish(*this);
linkRule->setLinkAttributes(attributes);
if (isExplicit) {
Boolean resultImplied;
const ElementType *resultType;
AttributeList resultAttributes;
if (!parseResultElementSpec(declInputLevel,
parm,
idlink,
resultImplied,
resultType,
resultAttributes))
return 0;
if (!resultImplied)
linkRule->setResult(resultType, resultAttributes);
}
// Install the link rule.
if (idlink) {
idLinkRule.setAssocElementTypes(assocElementTypes);
addIdLinkRule(id, idLinkRule);
}
else {
if (!linkSet->defined()) {
for (size_t i = 0; i < assocElementTypes.size(); i++)
if (assocElementTypes[i])
addLinkRule(linkSet, assocElementTypes[i], linkRuleResource);
}
}
}
} while (parm.type != Param::mdc);
if (linkSet)
linkSet->setDefined();
if (currentMarkup()) {
if (idlink)
eventHandler().idLinkDecl(new (eventAllocator())
IdLinkDeclEvent(defComplexLpdPointer(),
markupLocation(),
currentMarkup()));
else
eventHandler().linkDecl(new (eventAllocator())
LinkDeclEvent(linkSet,
defComplexLpdPointer(),
markupLocation(),
currentMarkup()));
}
return 1;
}
void Parser::addIdLinkRule(const StringC &id,
IdLinkRule &rule)
{
IdLinkRuleGroup *group = defComplexLpd().lookupCreateIdLink(id);
size_t nRules = group->nLinkRules();
if ((nRules == 1 && group->linkRule(0).attributes().nSpec() == 0)
|| nRules >= 1 && rule.attributes().nSpec() == 0)
message(ParserMessages::multipleIdLinkRuleAttribute,
StringMessageArg(id));
group->addLinkRule(rule);
}
void Parser::addLinkRule(LinkSet *linkSet,
const ElementType *sourceElement,
const ConstPtr<SourceLinkRuleResource> &linkRule)
{
size_t nRules = linkSet->nLinkRules(sourceElement);
if ((nRules == 1
&& linkSet->linkRule(sourceElement, 0).attributes().nSpec() == 0)
|| nRules >= 1 && linkRule->attributes().nSpec() == 0)
message(ParserMessages::multipleLinkRuleAttribute,
StringMessageArg(sourceElement->name()));
linkSet->addLinkRule(sourceElement, linkRule);
}
class ResultAttributeSpecModeSetter {
public:
ResultAttributeSpecModeSetter(ParserState *state) : state_(state) {
state_->setResultAttributeSpecMode();
}
~ResultAttributeSpecModeSetter() { clear(); }
void clear() {
if (state_) {
state_->clearResultAttributeSpecMode();
state_ = 0;
}
}
private:
ParserState *state_;
};
Boolean Parser::parseResultElementSpec(unsigned declInputLevel,
Param &parm,
Boolean idlink,
Boolean &implied,
const ElementType *&resultType,
AttributeList &attributes)
{
if (parm.type == Param::indicatedReservedName + Syntax::rIMPLIED) {
if (!parseParam(idlink ? allowNameMdc : allowExplicitLinkRuleMdc,
declInputLevel, parm))
return 0;
implied = 1;
}
else {
implied = 0;
ElementType *e = lookupResultElementType(parm.token);
resultType = e;
static AllowedParams
allow(Param::dso,
Param::mdc,
Param::name,
Param::nameGroup,
Param::indicatedReservedName + Syntax::rIMPLIED);
static AllowedParams
allowNameDsoMdc(Param::dso,
Param::mdc,
Param::name);
if (!parseParam(idlink ? allowNameDsoMdc : allow,
declInputLevel, parm))
return 0;
ConstPtr<AttributeDefinitionList> attDef;
if (e)
attDef = e->attributeDef();
attributes.init(attDef);
if (parm.type == Param::dso) {
ResultAttributeSpecModeSetter modeSetter(this);
Boolean netEnabling;
Ptr<AttributeDefinitionList> newAttDef;
if (!parseAttributeSpec(asMode, attributes, netEnabling, newAttDef))
return 0;
if (!newAttDef.isNull()) {
Ptr<Dtd> r(defComplexLpd().resultDtd());
if (!r.isNull()) {
newAttDef->setIndex(r->allocAttributeDefinitionListIndex());
if (e)
e->setAttributeDef(newAttDef);
}
}
modeSetter.clear();
if (attributes.nSpec() == 0)
message(ParserMessages::emptyResultAttributeSpec);
if (!parseParam(idlink ? allowNameMdc : allowExplicitLinkRuleMdc,
declInputLevel, parm))
return 0;
}
else {
// For entity and notation attributes.
ResultAttributeSpecModeSetter modeSetter(this);
attributes.finish(*this);
modeSetter.clear();
}
}
return 1;
}
ElementType *Parser::lookupResultElementType(const StringC &name)
{
Dtd *dtd = defComplexLpd().resultDtd().pointer();
if (!dtd)
return 0;
ElementType *e = dtd->lookupElementType(name);
if (!e)
message(ParserMessages::noSuchResultElement, StringMessageArg(name));
return e;
}
Boolean Parser::parseUselinkDecl()
{
unsigned declInputLevel = inputLevel();
Param parm;
if (!parseParam(allowLinkSetSpec, declInputLevel, parm))
return 0;
Param parm2;
if (!parseParam(allowName, declInputLevel, parm2))
return 0;
StringC linkType;
parm2.token.swap(linkType);
if (!parseParam(allowMdc, declInputLevel, parm2))
return 0;
ConstPtr<Lpd> lpd = lookupLpd(linkType);
if (lpd.isNull())
message(ParserMessages::uselinkBadLinkType, StringMessageArg(linkType));
else if (lpd->type() == Lpd::simpleLink)
message(ParserMessages::uselinkSimpleLpd, StringMessageArg(linkType));
else {
const ComplexLpd *complexLpd = (const ComplexLpd *)lpd.pointer();
const LinkSet *linkSet;
Boolean restore = 0;
if (parm.type == Param::name) {
linkSet = complexLpd->lookupLinkSet(parm.token);
if (!linkSet) {
message(ParserMessages::uselinkBadLinkSet,
StringMessageArg(complexLpd->name()),
StringMessageArg(parm.token));
return 1;
}
}
else if (parm.type == Param::indicatedReservedName + Syntax::rINITIAL)
linkSet = complexLpd->initialLinkSet();
else if (parm.type == Param::indicatedReservedName + Syntax::rEMPTY)
linkSet = complexLpd->emptyLinkSet();
else {
linkSet = 0;
restore = 1;
}
if (lpd->active())
eventHandler().uselink(new (eventAllocator())
UselinkEvent(lpd, linkSet,
restore, markupLocation(),
currentMarkup()));
else
eventHandler().ignoredMarkup(new (eventAllocator())
IgnoredMarkupEvent(markupLocation(),
currentMarkup()));
}
return 1;
}
LinkSet *Parser::lookupCreateLinkSet(const StringC &name)
{
LinkSet *linkSet = defComplexLpd().lookupLinkSet(name);
if (!linkSet) {
linkSet = new LinkSet(name, defComplexLpd().sourceDtd().pointer());
defComplexLpd().insertLinkSet(linkSet);
}
return linkSet;
}
Boolean Parser::parseMarkedSectionDeclStart()
{
if (markedSectionLevel() == syntax().taglvl())
message(ParserMessages::markedSectionLevel,
NumberMessageArg(syntax().taglvl()));
if (!inInstance()
&& options().warnInternalSubsetMarkedSection
&& inputLevel() == 1)
message(ParserMessages::internalSubsetMarkedSection);
if (markedSectionSpecialLevel() > 0) {
startMarkedSection(markupLocation());
if (inInstance()
? eventsWanted().wantMarkedSections()
: eventsWanted().wantPrologMarkup())
eventHandler().ignoredChars(new (eventAllocator())
IgnoredCharsEvent(currentInput()->currentTokenStart(),
currentInput()->currentTokenLength(),
currentLocation(),
0));
return 1;
}
Boolean discardMarkup;
if (startMarkup(inInstance()
? eventsWanted().wantMarkedSections()
: eventsWanted().wantPrologMarkup(),
currentLocation())) {
currentMarkup()->addDelim(Syntax::dMDO);
currentMarkup()->addDelim(Syntax::dDSO);
discardMarkup = 0;
}
else if (options().warnInstanceStatusKeywordSpecS && inInstance()) {
startMarkup(1, currentLocation());
discardMarkup = 1;
}
unsigned declInputLevel = inputLevel();
static AllowedParams allowStatusDso(Param::dso,
Param::reservedName + Syntax::rCDATA,
Param::reservedName + Syntax::rRCDATA,
Param::reservedName + Syntax::rIGNORE,
Param::reservedName + Syntax::rINCLUDE,
Param::reservedName + Syntax::rTEMP);
Param parm;
MarkedSectionEvent::Status status = MarkedSectionEvent::include;
if (!parseParam(allowStatusDso, declInputLevel, parm))
return 0;
if (options().warnMissingStatusKeyword && parm.type == Param::dso)
message(ParserMessages::missingStatusKeyword);
while (parm.type != Param::dso) {
switch (parm.type) {
case Param::reservedName + Syntax::rCDATA:
if (status < MarkedSectionEvent::cdata)
status = MarkedSectionEvent::cdata;
break;
case Param::reservedName + Syntax::rRCDATA:
if (status < MarkedSectionEvent::rcdata)
status = MarkedSectionEvent::rcdata;
if (options().warnRcdataMarkedSection)
message(ParserMessages::rcdataMarkedSection);
break;
case Param::reservedName + Syntax::rIGNORE:
if (status < MarkedSectionEvent::ignore)
status = MarkedSectionEvent::ignore;
if (inInstance() && options().warnInstanceIgnoreMarkedSection)
message(ParserMessages::instanceIgnoreMarkedSection);
break;
case Param::reservedName + Syntax::rINCLUDE:
if (inInstance() && options().warnInstanceIncludeMarkedSection)
message(ParserMessages::instanceIncludeMarkedSection);
break;
case Param::reservedName + Syntax::rTEMP:
if (options().warnTempMarkedSection)
message(ParserMessages::tempMarkedSection);
break;
}
if (!parseParam(allowStatusDso, declInputLevel, parm))
return 0;
if (options().warnMultipleStatusKeyword
&& parm.type != Param::dso)
message(ParserMessages::multipleStatusKeyword);
}
// FIXME this disallows
// <!entity % e "include [ stuff ">
// ...
// <![ %e; ]]>
// which I think is legal.
if (inputLevel() > declInputLevel)
message(ParserMessages::parameterEntityNotEnded);
switch (status) {
case MarkedSectionEvent::include:
startMarkedSection(markupLocation());
break;
case MarkedSectionEvent::cdata:
startSpecialMarkedSection(cmsMode, markupLocation());
break;
case MarkedSectionEvent::rcdata:
startSpecialMarkedSection(rcmsMode, markupLocation());
break;
case MarkedSectionEvent::ignore:
startSpecialMarkedSection(imsMode, markupLocation());
break;
}
if (currentMarkup()) {
if (options().warnInstanceStatusKeywordSpecS && inInstance()) {
Location loc(markupLocation());
for (MarkupIter iter(*currentMarkup()); iter.valid(); iter.advance(loc, syntaxPointer())) {
if (iter.type() == Markup::s) {
setNextLocation(loc);
message(ParserMessages::instanceStatusKeywordSpecS);
}
}
if (discardMarkup)
startMarkup(0, markupLocation());
}
eventHandler().markedSectionStart(new (eventAllocator())
MarkedSectionStartEvent(status,
markupLocation(),
currentMarkup()));
}
return 1;
}
void Parser::handleMarkedSectionEnd()
{
if (markedSectionLevel() == 0)
message(ParserMessages::markedSectionEnd);
else {
if (inInstance()
? eventsWanted().wantMarkedSections()
: eventsWanted().wantPrologMarkup()) {
if (markedSectionSpecialLevel() > 1)
eventHandler().ignoredChars(new (eventAllocator())
IgnoredCharsEvent(currentInput()->currentTokenStart(),
currentInput()->currentTokenLength(),
currentLocation(),
0));
else {
MarkedSectionEvent::Status status;
switch (currentMode()) {
case cmsMode:
status = MarkedSectionEvent::cdata;
break;
case rcmsMode:
status = MarkedSectionEvent::rcdata;
break;
case imsMode:
status = MarkedSectionEvent::ignore;
break;
default:
status = MarkedSectionEvent::include;
break;
}
startMarkup(1, currentLocation());
currentMarkup()->addDelim(Syntax::dMSC);
currentMarkup()->addDelim(Syntax::dMDC);
eventHandler().markedSectionEnd(new (eventAllocator())
MarkedSectionEndEvent(status,
markupLocation(),
currentMarkup()));
}
}
endMarkedSection();
}
}
void Parser::emptyCommentDecl()
{
if (startMarkup(eventsWanted().wantCommentDecls(), currentLocation())) {
currentMarkup()->addDelim(Syntax::dMDO);
currentMarkup()->addDelim(Syntax::dMDC);
eventHandler().commentDecl(new (eventAllocator())
CommentDeclEvent(markupLocation(),
currentMarkup()));
}
if (options().warnEmptyCommentDecl)
message(ParserMessages::emptyCommentDecl);
}
Boolean Parser::parseCommentDecl()
{
if (startMarkup(inInstance()
? eventsWanted().wantCommentDecls()
: eventsWanted().wantPrologMarkup(),
currentLocation()))
currentMarkup()->addDelim(Syntax::dMDO);
if (!parseComment(comMode))
return 0;
for (;;) {
Token token = getToken(mdMode);
switch (token) {
case tokenS:
if (currentMarkup())
currentMarkup()->addS(currentChar());
if (options().warnCommentDeclS)
message(ParserMessages::commentDeclS);
break;
case tokenCom:
if (!parseComment(comMode))
return 0;
if (options().warnCommentDeclMultiple)
message(ParserMessages::commentDeclMultiple);
break;
case tokenMdc:
if (currentMarkup())
currentMarkup()->addDelim(Syntax::dMDC);
goto done;
case tokenEe:
message(ParserMessages::declarationLevel);
return 0;
case tokenUnrecognized:
if (reportNonSgmlCharacter())
break;
// braces to work round Sun C++ 4.0 bug
{
message(ParserMessages::commentDeclarationCharacter,
StringMessageArg(currentToken()),
markupLocation());
}
return 0;
default:
// braces to work round Sun C++ 4.0 bug
{
message(ParserMessages::commentDeclInvalidToken,
TokenMessageArg(token, mdMode, syntaxPointer(), sdPointer()),
markupLocation());
}
return 0;
}
}
done:
if (currentMarkup())
eventHandler().commentDecl(new (eventAllocator())
CommentDeclEvent(markupLocation(),
currentMarkup()));
return 1;
}
Boolean Parser::parseAfdrDecl()
{
unsigned declInputLevel = inputLevel();
static AllowedParams allowMinimumLiteral(Param::minimumLiteral);
Param parm;
setHadAfdrDecl();
if (!parseParam(allowMinimumLiteral, declInputLevel, parm))
return 0;
if (parm.literalText.string() != sd().execToInternal("ISO/IEC 10744:1997"))
message(ParserMessages::afdrVersion,
StringMessageArg(parm.literalText.string()));
if (!parseParam(allowMdc, declInputLevel, parm))
return 0;
eventHandler().ignoredMarkup(new (eventAllocator())
IgnoredMarkupEvent(markupLocation(),
currentMarkup()));
return 1;
}
#ifdef SP_NAMESPACE
}
#endif