// Copyright (c) 1994 James Clark
// See the file COPYING for copying permission.
#ifdef __GNUG__
#pragma implementation
#endif
#include "splib.h"
#include "Attribute.h"
#include "MessageArg.h"
#include "macros.h"
#include "ParserMessages.h"
#include "Syntax.h"
#include "Entity.h"
#include "Notation.h"
#ifdef SP_NAMESPACE
namespace SP_NAMESPACE {
#endif
DeclaredValue::DeclaredValue()
{
}
DeclaredValue::~DeclaredValue()
{
}
AttributeValue *DeclaredValue::makeValueFromToken(Text &text,
AttributeContext &context,
const StringC &name,
unsigned &specLength) const
{
return makeValue(text, context, name, specLength);
}
AttributeSemantics *DeclaredValue::makeSemantics(const TokenizedAttributeValue &,
AttributeContext &,
const StringC &,
unsigned &,
unsigned &) const
{
return 0;
}
Boolean DeclaredValue::containsToken(const StringC &) const
{
return 0;
}
Boolean DeclaredValue::isNotation() const
{
return 0;
}
Boolean DeclaredValue::isEntity() const
{
return 0;
}
Boolean DeclaredValue::isId() const
{
return 0;
}
Boolean DeclaredValue::isIdref() const
{
return 0;
}
const Vector<StringC> *DeclaredValue::getTokens() const
{
return 0;
}
const Vector<StringC> *DeclaredValue::getOrigTokens() const
{
return 0;
}
CdataDeclaredValue::CdataDeclaredValue()
{
}
Boolean CdataDeclaredValue::tokenized() const
{
return 0;
}
void CdataDeclaredValue::checkNormalizedLength(Text &text,
AttributeContext &context,
unsigned &specLength) const
{
const Syntax &syntax = context.attributeSyntax();
size_t normsep = syntax.normsep();
size_t normalizedLength = text.normalizedLength(normsep);
specLength += normalizedLength;
size_t litlen = syntax.litlen();
// A length error will already have been given if
// length > litlen - normsep.
if (litlen >= normsep && text.size() <= litlen - normsep
&& normalizedLength > litlen)
context.message(ParserMessages::normalizedAttributeValueLength,
NumberMessageArg(litlen),
NumberMessageArg(normalizedLength));
}
AttributeValue *CdataDeclaredValue::makeValue(Text &text, AttributeContext &context,
const StringC &,
unsigned &specLength) const
{
checkNormalizedLength(text, context, specLength);
return new CdataAttributeValue(text);
}
void CdataDeclaredValue::buildDesc(AttributeDefinitionDesc &desc) const
{
desc.declaredValue = AttributeDefinitionDesc::cdata;
}
DeclaredValue *CdataDeclaredValue::copy() const
{
return new CdataDeclaredValue(*this);
}
DataDeclaredValue::DataDeclaredValue(const ConstPtr<Notation> &nt,
AttributeList &attributes)
: notation_(nt)
{
attributes.swap(attributes_);
}
AttributeValue *DataDeclaredValue::makeValue(Text &text,
AttributeContext &context,
const StringC &,
unsigned &specLength) const
{
checkNormalizedLength(text, context, specLength);
return new DataAttributeValue(text, notation_, attributes_);
}
DeclaredValue *DataDeclaredValue::copy() const
{
return new DataDeclaredValue(*this);
}
TokenizedDeclaredValue::TokenizedDeclaredValue(TokenType type,
Boolean isList)
: type_(type), isList_(isList)
{
switch (type) {
case name:
case entityName:
initialCategories_ = Syntax::nameStartCategory;
subsequentCategories_ = (Syntax::nameStartCategory|Syntax::digitCategory
| Syntax::otherNameCategory);
break;
case number:
initialCategories_ = Syntax::digitCategory;
subsequentCategories_ = Syntax::digitCategory;
break;
case nameToken:
initialCategories_ = (Syntax::nameStartCategory|Syntax::digitCategory
| Syntax::otherNameCategory);
subsequentCategories_ = initialCategories_;
break;
case numberToken:
initialCategories_ = Syntax::digitCategory;
subsequentCategories_ = (Syntax::nameStartCategory|Syntax::digitCategory
| Syntax::otherNameCategory);
break;
}
}
Boolean TokenizedDeclaredValue::tokenized() const
{
return 1;
}
AttributeValue *TokenizedDeclaredValue::makeValue(Text &text,
AttributeContext &context,
const StringC &str,
unsigned &specLength) const
{
return makeTokenizedValue(text, context, str, specLength);
}
TokenizedAttributeValue *
TokenizedDeclaredValue::makeTokenizedValue(Text &text,
AttributeContext &context,
const StringC &name,
unsigned &specLength) const
{
Vector<size_t> spaceIndex;
const Syntax &syntax = context.attributeSyntax();
Char space = syntax.space();
text.subst(*(type_ == entityName
? syntax.entitySubstTable()
: syntax.generalSubstTable()),
space);
const StringC &value = text.string();
size_t i = 0;
size_t length = value.size();
for (;;) {
if (i >= length) {
// ends with a space (which would have to have been entered
// via a numeric character reference)
if (context.validate())
context.message(ParserMessages::attributeValueSyntax);
break;
}
size_t startIndex = i;
if (context.validate()) {
if (!(syntax.charCategory(value[i]) & initialCategories_)) {
context.Messenger::setNextLocation(text.charLocation(i));
Char c = value[i];
if (!(syntax.charCategory(value[i]) & subsequentCategories_))
context.message(ParserMessages::attributeValueChar,
StringMessageArg(StringC(&c, 1)),
StringMessageArg(name));
else if (initialCategories_ == Syntax::digitCategory)
context.message(ParserMessages::attributeValueNumberToken,
StringMessageArg(StringC(&c, 1)),
StringMessageArg(name));
else
context.message(ParserMessages::attributeValueName,
StringMessageArg(StringC(&c, 1)),
StringMessageArg(name));
}
else {
for (++i;
i < length
&& (syntax.charCategory(value[i]) & subsequentCategories_);
i++)
;
if (i < length && value[i] != space) {
Char c = value[i];
// character value[i] is not allowed anywhere in the value
context.Messenger::setNextLocation(text.charLocation(i));
context.message(ParserMessages::attributeValueChar,
StringMessageArg(StringC(&c, 1)),
StringMessageArg(name));
}
}
}
while (i < length && value[i] != space)
i++;
if (i - startIndex > syntax.namelen()) {
context.Messenger::setNextLocation(text.charLocation(i));
context.message(ParserMessages::nameTokenLength,
NumberMessageArg(syntax.namelen()));
}
if (i == length)
break;
if (!isList_ && context.validate() && spaceIndex.size() == 0) {
context.Messenger::setNextLocation(text.charLocation(i));
context.message(ParserMessages::attributeValueMultiple,
StringMessageArg(name));
}
spaceIndex.push_back(i);
i++;
}
size_t normsep = syntax.normsep();
size_t litlen = syntax.litlen();
size_t normalizedLength = normsep + length;
// should we count CDATA and SDATA entities here?
if (isList_) {
normalizedLength += 1;
// length is now the number of characters in each token in the list
// + 1 for each token in the list; so add normsep - 1 for each
// token in the list.
if (normsep > 0)
normalizedLength += (normsep - 1)*(spaceIndex.size() + 1);
else
normalizedLength -= spaceIndex.size() + 1;
}
specLength += normalizedLength;
// A length error will already have been given if
// length > litlen - normsep.
if (litlen >= normsep && length <= litlen - normsep
&& normalizedLength > litlen)
context.message(ParserMessages::normalizedAttributeValueLength,
NumberMessageArg(litlen),
NumberMessageArg(normalizedLength));
return new TokenizedAttributeValue(text, spaceIndex);
}
Boolean TokenizedAttributeValue::recoverUnquoted(const StringC &str,
const Location &strLoc,
AttributeContext &context,
const StringC &name)
{
TextIter iter(text_);
TextItem::Type type;
const Char *s;
size_t len;
const Location *loc;
if (iter.next(type, s, len, loc)
&& type == TextItem::data
&& len == text_.size()
&& loc->origin().pointer() == strLoc.origin().pointer()
&& loc->index() + len == strLoc.index()
&& !iter.next(type, s, len, loc)) {
context.Messenger::setNextLocation(strLoc);
context.message(ParserMessages::attributeValueChar,
StringMessageArg(StringC(str.data(), 1)),
StringMessageArg(name));
return 1;
}
return 0;
}
void TokenizedDeclaredValue::buildDesc(AttributeDefinitionDesc &desc) const
{
desc.declaredValue = AttributeDefinitionDesc::DeclaredValue(
type_ - name + (isList_
? AttributeDefinitionDesc::names
: AttributeDefinitionDesc::name));
}
DeclaredValue *TokenizedDeclaredValue::copy() const
{
return new TokenizedDeclaredValue(*this);
}
GroupDeclaredValue::GroupDeclaredValue(TokenType type,
Vector<StringC> &vec)
: TokenizedDeclaredValue(type, 0)
{
vec.swap(allowedValues_);
}
void GroupDeclaredValue::buildDesc(AttributeDefinitionDesc &desc) const
{
desc.allowedValues = allowedValues_;
desc.origAllowedValues = origAllowedValues_;
}
DeclaredValue *GroupDeclaredValue::copy() const
{
return new GroupDeclaredValue(*this);
}
void GroupDeclaredValue::setOrigAllowedValues(Vector<StringC> &origAllowedValues)
{
origAllowedValues.swap(origAllowedValues_);
}
AttributeValue *GroupDeclaredValue::makeValue(Text &text,
AttributeContext &context,
const StringC &name,
unsigned &specLength) const
{
TokenizedAttributeValue *val = makeTokenizedValue(text, context, name,
specLength);
if (!val || !context.validate())
return val;
for (size_t i = 0; i < allowedValues_.size(); i++)
if (val->string() == allowedValues_[i])
return val;
context.message(ParserMessages::attributeValueNotInGroup,
StringMessageArg(val->string()),
StringMessageArg(name),
StringVectorMessageArg(allowedValues_));
return val;
}
AttributeValue *GroupDeclaredValue::makeValueFromToken(Text &text,
AttributeContext &context,
const StringC &,
unsigned &specLength)
const
{
const Syntax &syntax = context.attributeSyntax();
size_t litlen = syntax.litlen();
size_t normsep = syntax.normsep();
if (normsep > litlen || text.size() > litlen - normsep)
context.message(ParserMessages::normalizedAttributeValueLength,
NumberMessageArg(litlen),
NumberMessageArg(text.size() + normsep));
specLength += text.size() + normsep;
return new TokenizedAttributeValue(text, Vector<size_t>());
}
Boolean GroupDeclaredValue::containsToken(const StringC &token) const
{
for (size_t i = 0; i < allowedValues_.size(); i++)
if (allowedValues_[i] == token)
return 1;
return 0;
}
const Vector<StringC> *GroupDeclaredValue::getTokens() const
{
return &allowedValues_;
}
const Vector<StringC> *GroupDeclaredValue::getOrigTokens() const
{
return &origAllowedValues_;
}
NameTokenGroupDeclaredValue::NameTokenGroupDeclaredValue(Vector<StringC> &vec)
: GroupDeclaredValue(nameToken, vec)
{
}
void NameTokenGroupDeclaredValue::buildDesc(AttributeDefinitionDesc &desc) const
{
GroupDeclaredValue::buildDesc(desc);
desc.declaredValue = AttributeDefinitionDesc::nameTokenGroup;
}
DeclaredValue *NameTokenGroupDeclaredValue::copy() const
{
return new NameTokenGroupDeclaredValue(*this);
}
NotationDeclaredValue::NotationDeclaredValue(Vector<StringC> &vec)
: GroupDeclaredValue(name, vec)
{
}
Boolean NotationDeclaredValue::isNotation() const
{
return 1;
}
AttributeSemantics *
NotationDeclaredValue::makeSemantics(const TokenizedAttributeValue &value,
AttributeContext &context,
const StringC &,
unsigned &,
unsigned &) const
{
ConstPtr<Notation> notation
= context.getAttributeNotation(value.string(),
value.tokenLocation(0));
if (notation.isNull()) {
if (context.validate()) {
context.setNextLocation(value.tokenLocation(0));
context.message(ParserMessages::invalidNotationAttribute,
StringMessageArg(value.string()));
}
return 0;
}
return new NotationAttributeSemantics(notation);
}
void NotationDeclaredValue::buildDesc(AttributeDefinitionDesc &desc) const
{
GroupDeclaredValue::buildDesc(desc);
desc.declaredValue = AttributeDefinitionDesc::notation;
}
DeclaredValue *NotationDeclaredValue::copy() const
{
return new NotationDeclaredValue(*this);
}
EntityDeclaredValue::EntityDeclaredValue(Boolean isList)
: TokenizedDeclaredValue(entityName, isList)
{
}
Boolean EntityDeclaredValue::isEntity() const
{
return 1;
}
AttributeSemantics *
EntityDeclaredValue::makeSemantics(const TokenizedAttributeValue &value,
AttributeContext &context,
const StringC &,
unsigned &,
unsigned &nEntityNames) const
{
Boolean valid = 1;
size_t nTokens = value.nTokens();
nEntityNames += nTokens;
Vector<ConstPtr<Entity> > entities(nTokens);
for (size_t i = 0; i < nTokens; i++) {
entities[i] = context.getAttributeEntity(value.token(i),
value.tokenLocation(i));
if (entities[i].isNull()) {
if (context.validate()) {
context.setNextLocation(value.tokenLocation(i));
context.message(ParserMessages::invalidEntityAttribute,
StringMessageArg(value.token(i)));
}
valid = 0;
}
else if (!entities[i]->isDataOrSubdoc()) {
if (context.validate()) {
context.Messenger::setNextLocation(value.tokenLocation(i));
context.message(ParserMessages::notDataOrSubdocEntity,
StringMessageArg(value.token(i)));
}
valid = 0;
}
}
if (valid)
return new EntityAttributeSemantics(entities);
else
return 0;
}
DeclaredValue *EntityDeclaredValue::copy() const
{
return new EntityDeclaredValue(*this);
}
IdDeclaredValue::IdDeclaredValue()
: TokenizedDeclaredValue(name, 0)
{
}
Boolean IdDeclaredValue::isId() const
{
return 1;
}
AttributeSemantics *
IdDeclaredValue::makeSemantics(const TokenizedAttributeValue &value,
AttributeContext &context,
const StringC &,
unsigned &,
unsigned &) const
{
Location prevLoc;
if (!context.defineId(value.string(), value.tokenLocation(0), prevLoc)) {
context.setNextLocation(value.tokenLocation(0));
context.message(ParserMessages::duplicateId,
StringMessageArg(value.string()),
prevLoc);
}
return 0;
}
void IdDeclaredValue::buildDesc(AttributeDefinitionDesc &desc) const
{
desc.declaredValue = AttributeDefinitionDesc::id;
}
DeclaredValue *IdDeclaredValue::copy() const
{
return new IdDeclaredValue(*this);
}
IdrefDeclaredValue::IdrefDeclaredValue(Boolean isList)
: TokenizedDeclaredValue(name, isList)
{
}
AttributeSemantics *
IdrefDeclaredValue::makeSemantics(const TokenizedAttributeValue &value,
AttributeContext &context,
const StringC &,
unsigned &nIdrefs,
unsigned &) const
{
size_t nTokens = value.nTokens();
nIdrefs += nTokens;
for (size_t i = 0; i < nTokens; i++)
context.noteIdref(value.token(i), value.tokenLocation(i));
return 0;
}
Boolean IdrefDeclaredValue::isIdref() const
{
return 1;
}
void IdrefDeclaredValue::buildDesc(AttributeDefinitionDesc &desc) const
{
TokenizedDeclaredValue::buildDesc(desc);
if (desc.declaredValue == AttributeDefinitionDesc::name)
desc.declaredValue = AttributeDefinitionDesc::idref;
else
desc.declaredValue = AttributeDefinitionDesc::idrefs;
}
DeclaredValue *IdrefDeclaredValue::copy() const
{
return new IdrefDeclaredValue(*this);
}
AttributeDefinition::AttributeDefinition(const StringC &name,
DeclaredValue *value)
: name_(name), declaredValue_(value), implicit_(0), all_(0)
{
}
void AttributeDefinition::setSpecified(Boolean implicit)
{
(implicit ? implicit_ : all_) = 1;
}
Boolean AttributeDefinition::isSpecified(Boolean &implicit)
{
implicit = implicit_;
return implicit_ || all_;
}
void AttributeDefinition::setOrigName(StringC &origName)
{
if (&origName != NULL)
origName.swap(origName_);
}
AttributeDefinition::~AttributeDefinition()
{
}
AttributeValue *AttributeDefinition::checkValue(AttributeValue *p,
AttributeContext &) const
{
return p;
}
Boolean AttributeDefinition::missingValueWouldMatch(const Text &,
const AttributeContext &) const
{
return 0;
}
const AttributeValue *
AttributeDefinition::defaultValue(const AttributeValue *) const
{
return 0;
}
void AttributeDefinition::getDesc(AttributeDefinitionDesc &desc) const
{
desc.allowedValues.clear();
desc.defaultValue.clear();
desc.currentIndex = 0;
buildDesc(desc);
declaredValue_->buildDesc(desc);
}
Boolean AttributeDefinition::isConref() const
{
return 0;
}
Boolean AttributeDefinition::isCurrent() const
{
return 0;
}
Boolean AttributeDefinition::isFixed() const
{
return 0;
}
RequiredAttributeDefinition::RequiredAttributeDefinition(const StringC &name,
DeclaredValue *value)
: AttributeDefinition(name, value)
{
}
ConstPtr<AttributeValue>
RequiredAttributeDefinition::makeMissingValue(AttributeContext &context) const
{
if (context.validate())
context.message(ParserMessages::requiredAttributeMissing,
StringMessageArg(name()));
return 0;
}
void RequiredAttributeDefinition::buildDesc(AttributeDefinitionDesc &desc) const
{
desc.defaultValueType = AttributeDefinitionDesc::required;
}
AttributeDefinition *RequiredAttributeDefinition::copy() const
{
return new RequiredAttributeDefinition(*this);
}
CurrentAttributeDefinition::CurrentAttributeDefinition(const StringC &name, DeclaredValue *value, size_t index)
: AttributeDefinition(name, value), currentIndex_(index)
{
}
ConstPtr<AttributeValue>
CurrentAttributeDefinition::makeMissingValue(AttributeContext &context) const
{
if (context.mayDefaultAttribute()) {
ConstPtr<AttributeValue> currentValue
= context.getCurrentAttribute(currentIndex_);
if (currentValue.isNull() && context.validate())
context.message(ParserMessages::currentAttributeMissing,
StringMessageArg(name()));
return currentValue;
}
if (context.validate())
context.message(ParserMessages::attributeMissing,
StringMessageArg(name()));
return 0;
}
Boolean CurrentAttributeDefinition::missingValueWouldMatch(const Text &text,
const AttributeContext &context) const
{
if (!context.mayDefaultAttribute())
return 0;
ConstPtr<AttributeValue> currentValue
= context.getCurrentAttribute(currentIndex_);
if (currentValue.isNull())
return 0;
return text.fixedEqual(*currentValue->text());
}
AttributeValue *
CurrentAttributeDefinition::checkValue(AttributeValue *value,
AttributeContext &context) const
{
context.noteCurrentAttribute(currentIndex_, value);
return value;
}
void CurrentAttributeDefinition::buildDesc(AttributeDefinitionDesc &desc) const
{
desc.defaultValueType = AttributeDefinitionDesc::current;
desc.currentIndex = currentIndex_;
}
AttributeDefinition *CurrentAttributeDefinition::copy() const
{
return new CurrentAttributeDefinition(*this);
}
Boolean CurrentAttributeDefinition::isCurrent() const
{
return 1;
}
ImpliedAttributeDefinition::ImpliedAttributeDefinition(const StringC &name,
DeclaredValue *value)
: AttributeDefinition(name, value)
{
}
ConstPtr<AttributeValue>
ImpliedAttributeDefinition::makeMissingValue(AttributeContext &context) const
{
return context.makeImpliedAttributeValue();
}
void ImpliedAttributeDefinition::buildDesc(AttributeDefinitionDesc &desc) const
{
desc.defaultValueType = AttributeDefinitionDesc::implied;
}
AttributeDefinition *ImpliedAttributeDefinition::copy() const
{
return new ImpliedAttributeDefinition(*this);
}
const AttributeValue *
ImpliedAttributeDefinition::defaultValue(const AttributeValue *impliedValue)
const
{
return impliedValue;
}
ConrefAttributeDefinition::ConrefAttributeDefinition(const StringC &name,
DeclaredValue *value)
: ImpliedAttributeDefinition(name, value)
{
}
Boolean ConrefAttributeDefinition::isConref() const
{
return 1;
}
void ConrefAttributeDefinition::buildDesc(AttributeDefinitionDesc &desc) const
{
desc.defaultValueType = AttributeDefinitionDesc::conref;
}
AttributeDefinition *ConrefAttributeDefinition::copy() const
{
return new ConrefAttributeDefinition(*this);
}
DefaultAttributeDefinition::DefaultAttributeDefinition(const StringC &name,
DeclaredValue *declaredValue,
AttributeValue *defaultValue)
: AttributeDefinition(name, declaredValue),
value_(defaultValue)
{
}
ConstPtr<AttributeValue>
DefaultAttributeDefinition::makeMissingValue(AttributeContext &context) const
{
if (context.mayDefaultAttribute())
return value_;
if (context.validate())
context.message(ParserMessages::attributeMissing,
StringMessageArg(name()));
return 0;
}
Boolean DefaultAttributeDefinition::missingValueWouldMatch(const Text &text,
const AttributeContext &context) const
{
return context.mayDefaultAttribute() && text.fixedEqual(*value_->text());
}
void DefaultAttributeDefinition::buildDesc(AttributeDefinitionDesc &desc) const
{
desc.defaultValueType = AttributeDefinitionDesc::defaulted;
desc.defaultValue = value_;
}
AttributeDefinition *DefaultAttributeDefinition::copy() const
{
return new DefaultAttributeDefinition(*this);
}
FixedAttributeDefinition:: FixedAttributeDefinition(const StringC &name,
DeclaredValue *declaredValue,
AttributeValue *defaultValue)
: DefaultAttributeDefinition(name, declaredValue, defaultValue)
{
}
Boolean FixedAttributeDefinition::isFixed() const
{
return 1;
}
AttributeValue *FixedAttributeDefinition::checkValue(AttributeValue *value,
AttributeContext &context)
const
{
const AttributeValue *fixedValue
= DefaultAttributeDefinition::defaultValue(0);
if (value && fixedValue && context.validate()) {
const Text *text;
const StringC *str;
const Text *fixedText;
const StringC *fixedStr;
switch (value->info(text, str)) {
case AttributeValue::implied:
CANNOT_HAPPEN();
case AttributeValue::cdata:
if (fixedValue->info(fixedText, fixedStr) == AttributeValue::cdata) {
if (!text->fixedEqual(*fixedText))
context.message(ParserMessages::notFixedValue, StringMessageArg(name()));
}
break;
case AttributeValue::tokenized:
if (fixedValue->info(fixedText, fixedStr) == AttributeValue::tokenized) {
if (*str != *fixedStr)
context.message(ParserMessages::notFixedValue, StringMessageArg(name()));
}
break;
}
}
return value;
}
void FixedAttributeDefinition::buildDesc(AttributeDefinitionDesc &desc) const
{
// get the fixed value
DefaultAttributeDefinition::buildDesc(desc);
desc.defaultValueType = AttributeDefinitionDesc::fixed;
}
AttributeDefinition *FixedAttributeDefinition::copy() const
{
return new FixedAttributeDefinition(*this);
}
AttributeDefinitionList
::AttributeDefinitionList(Vector<CopyOwner<AttributeDefinition> > &vec,
size_t index,
Boolean anyCurrent,
size_t idIndex,
size_t notationIndex)
: index_(index), anyCurrent_(anyCurrent), idIndex_(idIndex),
notationIndex_(notationIndex)
{
defs_.swap(vec);
}
AttributeDefinitionList:: AttributeDefinitionList(const ConstPtr<AttributeDefinitionList> &def)
: prev_(def), index_(size_t(-1))
{
if (def.isNull()) {
anyCurrent_ = 0;
notationIndex_ = size_t(-1);
idIndex_ = size_t(-1);
}
else {
anyCurrent_ = def->anyCurrent_;
notationIndex_ = def->notationIndex_;
idIndex_ = def->idIndex_;
defs_ = def->defs_;
}
}
AttributeDefinitionList::~AttributeDefinitionList() {}
Boolean AttributeDefinitionList::tokenIndex(const StringC &token, unsigned &index) const
{
for (size_t i = 0; i < defs_.size(); i++)
if (defs_[i]->containsToken(token)) {
index = i;
return 1;
}
return 0;
}
Boolean AttributeDefinitionList::tokenIndexUnique(const StringC &token, unsigned i) const
{
for (++i; i < defs_.size(); i++)
if (defs_[i]->containsToken(token))
return 0;
return 1;
}
Boolean AttributeDefinitionList::attributeIndex(const StringC &name,
unsigned &index) const
{
for (size_t i = 0; i < defs_.size(); i++)
if (defs_[i]->name() == name) {
index = i;
return 1;
}
return 0;
}
void AttributeDefinitionList::append(AttributeDefinition *def)
{
if (def->isId() && idIndex_ == size_t(-1))
idIndex_ = defs_.size();
if (def->isNotation() && notationIndex_ == size_t(-1))
notationIndex_ = defs_.size();
if (def->isCurrent())
anyCurrent_ = 1;
defs_.resize(defs_.size() + 1);
defs_.back() = def;
}
AttributeSemantics::AttributeSemantics()
{
}
AttributeSemantics::~AttributeSemantics()
{
}
size_t AttributeSemantics::nEntities() const
{
return 0;
}
ConstPtr<Entity> AttributeSemantics::entity(size_t) const
{
return 0;
}
ConstPtr<Notation> AttributeSemantics::notation() const
{
return 0;
}
NotationAttributeSemantics::NotationAttributeSemantics(const ConstPtr<Notation> ¬ation)
: notation_(notation)
{
}
ConstPtr<Notation> NotationAttributeSemantics::notation() const
{
return notation_;
}
AttributeSemantics *NotationAttributeSemantics::copy() const
{
return new NotationAttributeSemantics(*this);
}
EntityAttributeSemantics::EntityAttributeSemantics(Vector<ConstPtr<Entity> > &entity)
{
entity.swap(entity_);
}
size_t EntityAttributeSemantics::nEntities() const
{
return entity_.size();
}
ConstPtr<Entity> EntityAttributeSemantics::entity(size_t i) const
{
return entity_[i];
}
AttributeSemantics *EntityAttributeSemantics::copy() const
{
return new EntityAttributeSemantics(*this);
}
AttributeValue::AttributeValue()
{
}
AttributeValue::~AttributeValue()
{
}
AttributeSemantics *AttributeValue::makeSemantics(const DeclaredValue *,
AttributeContext &,
const StringC &,
unsigned &,
unsigned &) const
{
return 0;
}
const Text *AttributeValue::text() const
{
return 0;
}
Boolean AttributeValue::recoverUnquoted(const StringC &, const Location &,
AttributeContext &, const StringC &)
{
return 0;
}
ImpliedAttributeValue::ImpliedAttributeValue()
{
}
AttributeValue::Type ImpliedAttributeValue::info(const Text *&,
const StringC *&) const
{
return implied;
}
TokenizedAttributeValue::TokenizedAttributeValue(Text &text,
const Vector<size_t> &spaceIndex)
: spaceIndex_(spaceIndex)
{
text.swap(text_);
}
AttributeValue::Type TokenizedAttributeValue::info(const Text *&,
const StringC *&string) const
{
string = &text_.string();
return tokenized;
}
const Text *TokenizedAttributeValue::text() const
{
return &text_;
}
AttributeSemantics *
TokenizedAttributeValue::makeSemantics(const DeclaredValue *value,
AttributeContext &context,
const StringC &name,
unsigned &nIdrefs,
unsigned &nEntityNames) const
{
if (text_.size() == 0)
return 0;
return value->makeSemantics(*this, context, name, nIdrefs, nEntityNames);
}
CdataAttributeValue::CdataAttributeValue(Text &text)
{
text.swap(text_);
}
AttributeValue::Type CdataAttributeValue::info(const Text *&text,
const StringC *&) const
{
text = &text_;
return cdata;
}
const Text *CdataAttributeValue::text() const
{
return &text_;
}
Boolean CdataAttributeValue::recoverUnquoted(const StringC &str,
const Location &strLoc,
AttributeContext &context,
const StringC &)
{
TextIter iter(text_);
TextItem::Type type;
const Char *s;
size_t len;
const Location *loc;
if (iter.next(type, s, len, loc)
&& type == TextItem::data
&& len == text_.size()
&& loc->origin().pointer() == strLoc.origin().pointer()
&& loc->index() + len == strLoc.index()
&& !iter.next(type, s, len, loc)) {
text_.addChars(str, strLoc);
context.Messenger::setNextLocation(strLoc);
context.message(ParserMessages::unquotedAttributeValue);
return 1;
}
return 0;
}
const Notation *CdataAttributeValue::notation() const
{
return 0;
}
DataAttributeValue::DataAttributeValue(Text &text,
const ConstPtr<Notation> &nt,
const AttributeList &attributes)
: CdataAttributeValue(text), notation_(nt), attributes_(&attributes)
{
}
const AttributeList &DataAttributeValue::attributes() const
{
return *attributes_;
}
const Notation *DataAttributeValue::notation() const
{
return notation_.pointer();
}
Attribute::Attribute()
: specIndexPlus_(0)
{
}
Attribute::Attribute(const Attribute& x)
: specIndexPlus_(x.specIndexPlus_),
value_(x.value_),
semantics_(x.semantics_)
{
}
Attribute::~Attribute()
{
}
Attribute& Attribute::operator=(const Attribute& x)
{
if (this != &x) {
specIndexPlus_ = x.specIndexPlus_;
value_ = x.value_;
semantics_ = x.semantics_;
}
return *this;
}
void Attribute::clear()
{
specIndexPlus_ = 0;
value_.clear();
semantics_.clear();
}
AttributeList::AttributeList(const ConstPtr<AttributeDefinitionList> &def)
: def_(def), vec_(def.isNull() ? 0 : def->size()), nSpec_(0), conref_(0),
nIdrefs_(0), nEntityNames_(0)
{
}
AttributeList::AttributeList()
: nSpec_(0), conref_(0)
{
}
void AttributeList::init(const ConstPtr<AttributeDefinitionList> &def)
{
def_ = def;
nSpec_ = 0;
conref_ = 0;
nIdrefs_ = 0;
nEntityNames_ = 0;
if (def_.isNull())
vec_.resize(0);
else {
size_t newLength = def_->size();
size_t clearLim = vec_.size();
if (clearLim > newLength)
clearLim = newLength;
vec_.resize(newLength);
for (size_t i = 0; i < clearLim; i++)
vec_[i].clear();
}
}
void AttributeList::changeDef(const ConstPtr<AttributeDefinitionList> &def)
{
vec_.resize(def.isNull() ? 0 : def->size());
def_ = def;
}
void AttributeList::swap(AttributeList &to)
{
vec_.swap(to.vec_);
def_.swap(to.def_);
{
unsigned tem = to.nIdrefs_;
to.nIdrefs_ = nIdrefs_;
nIdrefs_ = tem;
}
{
unsigned tem = to.nEntityNames_;
to.nEntityNames_ = nEntityNames_;
nEntityNames_ = tem;
}
{
size_t tem = to.nSpec_;
to.nSpec_ = nSpec_;
nSpec_ = tem;
}
{
PackedBoolean tem = to.conref_;
to.conref_ = conref_;
conref_ = tem;
}
}
void AttributeList::finish(AttributeContext &context)
{
for (size_t i = 0; i < vec_.size(); i++)
if (!vec_[i].specified()) {
ConstPtr<AttributeValue> value
= def(i)->makeMissingValue(context);
if (!conref_ || def_->notationIndex() != i) {
vec_[i].setValue(value);
if (!value.isNull())
vec_[i].setSemantics(def(i)->makeSemantics(value.pointer(),
context,
nIdrefs_,
nEntityNames_));
}
}
const Syntax &syntax = context.attributeSyntax();
if (nIdrefs_ > syntax.grpcnt())
context.message(ParserMessages::idrefGrpcnt,
NumberMessageArg(syntax.grpcnt()));
if (nEntityNames_ > syntax.grpcnt())
context.message(ParserMessages::entityNameGrpcnt,
NumberMessageArg(syntax.grpcnt()));
if (context.validate()
&& conref_
&& def_->notationIndex() != size_t(-1)
&& specified(def_->notationIndex()))
context.message(ParserMessages::conrefNotation);
}
void AttributeList::setSpec(unsigned i, AttributeContext &context)
{
if (vec_[i].specified())
context.message(ParserMessages::duplicateAttributeSpec,
StringMessageArg(def(i)->name()));
else
vec_[i].setSpec(nSpec_++);
}
void AttributeList::noteInvalidSpec()
{
// This is needed for error recovery.
// We don't want nSpec_ to be > 0, if there is no attribute definition.
if (nSpec_)
nSpec_++;
}
Boolean AttributeList::setValue(unsigned i, Text &text,
AttributeContext &context,
unsigned &specLength)
{
AttributeValue *value = def(i)->makeValue(text, context, specLength);
if (def(i)->isConref())
conref_ = 1;
vec_[i].setValue(value);
if (value)
vec_[i].setSemantics(def(i)->makeSemantics(value, context,
nIdrefs_, nEntityNames_));
else if (AttributeValue::handleAsUnterminated(text, context))
return 0;
return 1;
}
void AttributeList::setValueToken(unsigned i, Text &text,
AttributeContext &context,
unsigned &specLength)
{
AttributeValue *value = def(i)->makeValueFromToken(text, context,
specLength);
if (def(i)->isConref())
conref_ = 1;
vec_[i].setValue(value);
if (value)
vec_[i].setSemantics(def(i)->makeSemantics(value, context,
nIdrefs_, nEntityNames_));
}
const StringC *AttributeList::getId() const
{
// Check for no attributes
if (def_.isNull())
return 0;
// Check for no ID declared
size_t i = def_->idIndex();
if (i == size_t(-1))
return 0;
// Check for invalid value
const AttributeValue *v = value(i);
if (!v)
return 0;
// Check for implied value
const Text *t = v->text();
if (!t)
return 0;
return &t->string();
}
Boolean AttributeList::recoverUnquoted(const StringC &str,
const Location &strLoc,
AttributeContext &context)
{
if (nSpec_ > 0) {
for (size_t i = 0; i < vec_.size(); i++)
if (vec_[i].specified() && vec_[i].specIndex() == nSpec_ - 1) {
const AttributeValue *val = vec_[i].value();
if (val)
// I wish I could avoid casting away const here.
return ((AttributeValue *)val)->recoverUnquoted(str, strLoc, context,
name(i));
break;
}
return 1;
}
return 0;
}
Boolean AttributeList::handleAsUnterminated(AttributeContext &context)
{
if (nSpec_ > 0) {
for (size_t i = 0; i < vec_.size(); i++) {
if (vec_[i].specified() && vec_[i].specIndex() == nSpec_ - 1) {
const AttributeValue *val = vec_[i].value();
const Text *ptr;
if (val && (ptr = val->text()) != 0
&& AttributeValue::handleAsUnterminated(*ptr, context))
return 1;
break;
}
}
}
return 0;
}
// This tries to guess this attribute value looks like if it had
// a missing ending quote.
Boolean AttributeValue::handleAsUnterminated(const Text &text,
AttributeContext &context)
{
TextIter iter(text);
const Char *lastStr = 0;
size_t lastLen;
Location startLoc;
const Location *loc;
TextItem::Type type;
const Char *str;
size_t len;
while (iter.next(type, str, len, loc)) {
if (startLoc.origin().isNull() && !loc->origin().isNull())
startLoc = *loc;
switch (type) {
case TextItem::data:
if (len != 1 || *str != context.attributeSyntax().space()) {
lastStr = str;
lastLen = len;
}
break;
case TextItem::endDelim:
case TextItem::endDelimA:
case TextItem::ignore:
break;
default:
lastStr = 0;
break;
}
}
if (lastStr) {
while (lastLen > 0
&& lastStr[lastLen - 1] == context.attributeSyntax().space())
lastLen--;
const StringC &vi = context.attributeSyntax().delimGeneral(Syntax::dVI);
if (lastLen >= vi.size()
&& (vi
== StringC(lastStr + (lastLen - vi.size()), vi.size()))) {
context.Messenger::setNextLocation(startLoc);
context.message(ParserMessages::literalClosingDelimiter);
return 1;
}
}
return 0;
}
AttributeContext::AttributeContext()
: mayDefaultAttribute_(0), validate_(1)
{
}
AttributeContext::~AttributeContext()
{
}
Boolean AttributeContext::defineId(const StringC &, const Location &,
Location &)
{
return 1;
}
void AttributeContext::noteIdref(const StringC &, const Location &)
{
}
void AttributeContext::noteCurrentAttribute(size_t, AttributeValue *)
{
}
ConstPtr<AttributeValue> AttributeContext::getCurrentAttribute(size_t) const
{
return 0;
}
ConstPtr<Entity> AttributeContext::getAttributeEntity(const StringC &,
const Location &)
{
return 0;
}
ConstPtr<Notation> AttributeContext::getAttributeNotation(const StringC &,
const Location &)
{
return 0;
}
ConstPtr<AttributeValue> AttributeContext::makeImpliedAttributeValue()
{
if (impliedAttributeValue_.isNull())
impliedAttributeValue_ = new ImpliedAttributeValue;
return impliedAttributeValue_;
}
#ifdef SP_NAMESPACE
}
#endif