// 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);