copyeventhandler.cxx

SP是一个基于GNU C++编译器

	{
	  os() << iter;
	  for (size_t i = iter.charsLength();
	       i < event->name().size();
	       i++) {
	    handleChange();
	    os().put(event->name()[i]);
	  }
	  hadAttname = 1;
	}
	break;
      case Markup::delimiter:
	if (iter.delimGeneral() == Syntax::dTAGC) {
	  closed = 1;
	  if (!hadAttname
	      && (normalizeFlags_ & normalizeEmptytag)) {
	    handleChange();
	    StringC nameBuf;
	    os() << elementTypeOrigName(event->elementType(), nameBuf);
	  }
	}
	else if (iter.delimGeneral() == Syntax::dNET) {
	  closed = 1;
	  if (normalizeFlags_ & normalizeNet) {
	    handleChange();
	    StringC nameBuf;
	    os() << syntax_->delimGeneral(Syntax::dETAGO)
	         << elementTypeOrigName(event->elementType(), nameBuf)
	         << syntax_->delimGeneral(Syntax::dTAGC);
	    break;
	  }
	}
	os() << syntax_->delimGeneral(iter.delimGeneral());
	break;
      default:
	CANNOT_HAPPEN();
      }
    if (!closed && (normalizeFlags_ & normalizeUnclosed)) {
      handleChange();
      os() << syntax_->delimGeneral(Syntax::dTAGC);
    }
  }
  else if (normalizeFlags_ & normalizeOmittag) {
    if (inSpecialMarkedSection_) {
      reportTagInSpecialMarkedSection(event->location());
      return;
    }
    handleChange();
    StringC nameBuf;
    os() << syntax_->delimGeneral(Syntax::dETAGO)
      << elementTypeOrigName(event->elementType(), nameBuf)
	<< syntax_->delimGeneral(Syntax::dTAGC);
  }
  delete event;
  if (entityStack_.size() > 0 && os_ == topOs_)
    os_ = &entityStack_.back().str;
}

void CopyEventHandler::pi(PiEvent *event)
{
  omittagHoist_ = 0;
  if (doNothing(event))
    return;
  if (event->entity())
    entityRef(event->location().origin()->asEntityOrigin());
  else {
    os() << syntax_->delimGeneral(Syntax::dPIO);
    os().write(event->data(), event->dataLength());
    os() << syntax_->delimGeneral(Syntax::dPIC);
  }
  delete event;
}

void CopyEventHandler::sdataEntity(SdataEntityEvent *event)
{
  omittagHoist_ = 0;
  if (doNothing(event))
    return;
  entityRef(event->location().origin()->asEntityOrigin());
  delete event;
}

void CopyEventHandler::externalDataEntity(ExternalDataEntityEvent *event)
{
  omittagHoist_ = 0;
  if (doNothing(event))
    return;
  entityRef(event->entityOrigin().pointer());
  delete event;
}

void CopyEventHandler::subdocEntity(SubdocEntityEvent *event)
{
  omittagHoist_ = 0;
  if (doNothing(event))
    return;
  entityRef(event->entityOrigin().pointer());
  delete event;
}

void CopyEventHandler::markedSectionStart(MarkedSectionStartEvent *event)
{
  omittagHoist_ = 0;
  switch (event->status()) {
  case MarkedSectionEvent::rcdata:
  case MarkedSectionEvent::cdata:
    inSpecialMarkedSection_ = 1;
    break;
  default:
    break;
  }
  if (doNothing(event))
    return;
  if (!(normalizeFlags_ & normalizeMarkedSection)
      || (inInstance_ && inSpecialMarkedSection_))
    outputMarkup(event->location(), event->markup());
  else if (inInstance_ && event->status() != MarkedSectionEvent::ignore) {
    // Put an empty comment so that REs aren't changed.
    // With an ignored marked section, sufficent to have comment at the end.
    handleChange();
    os() << syntax_->delimGeneral(Syntax::dMDO)
         << syntax_->delimGeneral(Syntax::dMDC);
  }
  delete event;
}

void CopyEventHandler::markedSectionEnd(MarkedSectionEndEvent *event)
{
  omittagHoist_ = 0;
  if (doNothing(event)) {
    inSpecialMarkedSection_ = 0;
    return;
  }
  if (!(normalizeFlags_ & normalizeMarkedSection)
      || (inInstance_ && inSpecialMarkedSection_))
    outputMarkup(event->location(), event->markup());
  else if (inInstance_) {
    // Put an empty comment so that REs aren't changed.
    handleChange();
    os() << syntax_->delimGeneral(Syntax::dMDO)
         << syntax_->delimGeneral(Syntax::dMDC);
  }
  inSpecialMarkedSection_ = 0;
  delete event;
}

void CopyEventHandler::ignoredChars(IgnoredCharsEvent *event)
{
  omittagHoist_ = 0;
  if (doNothing(event))
    return;
  if (!(normalizeFlags_ & normalizeMarkedSection))
    os().write(event->data(), event->dataLength());
  delete event;
}

void CopyEventHandler::usemap(UsemapEvent *event)
{
  omittagHoist_ = 0;
  if (doNothing(event))
    return;
  if (!(normalizeFlags_ & normalizeShortref))
    outputMarkup(event->location(), event->markup());
  else if (inInstance_) {
    // Put an empty comment so that REs aren't changed.
    handleChange();
    os() << syntax_->delimGeneral(Syntax::dMDO)
         << syntax_->delimGeneral(Syntax::dMDC);
  }
  delete event;
}

void CopyEventHandler::uselink(UselinkEvent *event)
{
  omittagHoist_ = 0;
  markup(event->location(), event->markup());
  delete event;
}

void CopyEventHandler::startDtd(StartDtdEvent *event)
{
  startSubset(event);
}

void CopyEventHandler::startLpd(StartLpdEvent *event)
{
  startSubset(event);
}

void CopyEventHandler::startSubset(StartSubsetEvent *event)
{
  if (doNothing(event))
    return;
  if (!event->entity().isNull()
      && (normalizeFlags_ & normalizeExpandProlog)) {
    const Markup &m = event->markup();
    for (MarkupIter iter(m); iter.valid(); iter.advance())
      if (iter.type() == Markup::reservedName
	  && (iter.reservedName() == Syntax::rSYSTEM
	      || iter.reservedName() == Syntax::rPUBLIC)) {
	Markup copy(m);
	copy.resize(iter.index());
	outputMarkup(event->location(), copy);
	break;
      }
  }
  else
    outputMarkup(event->location(), event->markup());
  if (event->hasInternalSubset()
      || (normalizeFlags_ & normalizeExpandProlog)) {
    os() << syntax_->delimGeneral(Syntax::dDSO);
    hasInternalSubset_ = 1;
  }
  else
    hasInternalSubset_ = 0;
  delete event;
}

void CopyEventHandler::endDtd(EndDtdEvent *event)
{
  endSubset(event);
}

void CopyEventHandler::endLpd(EndLpdEvent *event)
{
  endSubset(event);
}

void CopyEventHandler::endSubset(MarkupEvent *event)
{
  if (doNothing(event))
    return;
  if (hasInternalSubset_)
    os() << syntax_->delimGeneral(Syntax::dDSC);
  outputMarkup(event->location(), event->markup());
  delete event;
}

void CopyEventHandler::entityDecl(EntityDeclEvent *event)
{
  currentAttributes_ = 0;
  const ExternalDataEntity *extData = event->entity().asExternalDataEntity();
  if (extData)
    currentAttributes_ = &extData->attributes();
  markup(event->location(), event->markup());
  currentAttributes_ = 0;
  delete event;
}

void CopyEventHandler::shortrefDecl(ShortrefDeclEvent *event)
{
  if (doNothing(event))
    return;
  if (!(normalizeFlags_ & normalizeShortref))
    outputMarkup(event->location(), event->markup());
  delete event;
}

void CopyEventHandler::entityStart(EntityStartEvent *event)
{
  if (event->entity()->name() == outputEntity_
      && event->entity()->declType() == Entity::generalEntity)
    outputEntityLevel_ = entityLevel_ + 1;
  if (inInstance_ && (normalizeFlags_ & normalizeOmittagHoist)) {
    if (event->entity()->asInternalEntity())
      omittagHoist_++;
    else
      omittagHoist_ = 0;
  }
  if (doNothing(event)) {
    entityLevel_++;
    return;
  }
  entityLevel_++;
  if ((normalizeFlags_ & normalizeExpand)
      && inInstance_
      && entityLevel_ > outputEntityLevel_) {
    entityStack_.resize(entityStack_.size() + 1);
    entityStack_.back().ref = event->entityOrigin();
    os_ = &entityStack_.back().str;
  }
  entityOrigin_ = event->entityOrigin();
  delete event;
}

void CopyEventHandler::entityEnd(EntityEndEvent *event)
{
  if (omittagHoist_ > 0)
    omittagHoist_--;
  if (entityLevel_-- == outputEntityLevel_) {
    outputEntityLevel_ = unsigned(-1);
    outputEntity_.resize(0);
  }
  else if (!(normalizeFlags_
	     & (inInstance_ ? normalizeExpand : normalizeExpandProlog))
	   && entityLevel_ == outputEntityLevel_) {
    if (!entityOrigin_.isNull()) {
      switch (entityOrigin_->entity()->declType()) {
      case Entity::doctype:
      case Entity::linktype:
	break;
      default:
	entityRef(entityOrigin_.pointer());
	break;
      }
    }
    entityOrigin_.clear();
  }
  else if ((normalizeFlags_ & normalizeExpand)
	   && inInstance_
	   && entityLevel_ >= outputEntityLevel_) {
    if (entityStack_.size() > 0) {
      ConstPtr<EntityOrigin> origin
	= entityStack_.back().ref;
      entityStack_.resize(entityStack_.size() - 1);
      if (entityStack_.size() > 0)
	os_ = &entityStack_.back().str;
      else
	os_ = topOs_;
      entityRef(origin.pointer());
    }
  }
  delete event;
}

void CopyEventHandler::outputMarkup(const Location &loc,
				    const Markup &markup)
{
  int level = 0;
  Boolean first = 1;
  MarkupIter iter(markup);
  while (iter.valid()) {
    switch (iter.type()) {
    case Markup::delimiter:
      if (first)
	withNamedCharRef(syntax_->delimGeneral(iter.delimGeneral()), loc);
      else if (!level) {
	os() << syntax_->delimGeneral(iter.delimGeneral());
	// hack, hack!
	if (iter.delimGeneral() == Syntax::dDSO && currentAttributes_ != 0) {
	  attributeSpecList(iter, *currentAttributes_);
	  first = 0;
	  continue;		// skip the advance
	}
      }
      break;
    case Markup::refEndRe:
      if (!level)
	os().put(syntax_->standardFunction(Syntax::fRE));
      break;
    case Markup::sdReservedName:
      if (!level) {
	if (normalizeFlags_ & normalizeReserved)
	  os() << sd_->reservedName(iter.sdReservedName());
	else
	  os() << iter;
      }
      break;
    case Markup::reservedName:
      if (!level && (normalizeFlags_ & normalizeReserved)) {
	os() << syntax_->reservedName(iter.reservedName());
	break;
      }
    case Markup::shortref:
      if (first) {
	withNamedCharRef(iter.charsPointer(), iter.charsLength(), loc);
	break;
      }
      // fall through
    case Markup::name:
    case Markup::nameToken:
    case Markup::attributeValue:
    case Markup::number:
    case Markup::s:
      if (!level)
	os() << iter;
      break;
    case Markup::comment:
      if (!level)
	os() << syntax_->delimGeneral(Syntax::dCOM)
	     << iter
	     << syntax_->delimGeneral(Syntax::dCOM);
      break;
    case Markup::entityStart:
      if (!level++) {
	const EntityOrigin *origin = iter.entityOrigin();
	// entityStarts in the SGML declaration don't have explicit references
	if (origin->entity())
	  entityRef(origin);
      }
      break;
    case Markup::entityEnd:
      level--;
      break;
    case Markup::literal:
      if (!level)
	literal(iter.text());
      break;
    case Markup::sdLiteral:
      if (!level)
	sdParamLiteral(iter.sdText());
      break;
    default:
      CANNOT_HAPPEN();
    }
    iter.advance();
    first = 0;
  }
}

void CopyEventHandler::sdParamLiteral(const SdText &text)
{
  const StringC &delim = syntax_->delimGeneral(text.lita()
					       ? Syntax::dLITA
					       : Syntax::dLIT);
  os() << delim;
  SdTextIter iter(text);
  const SyntaxChar *p;
  size_t n;
  Location loc;
  while (iter.next(p, n, loc)) {
    const Markup *markupPtr;
    if (n == 1 && loc.origin()->isNumericCharRef(markupPtr)) {
      if (markupPtr)
	outputMarkup(loc.origin()->parent(), *markupPtr);
    }
    else if (n > 0) {
      Char c = Char(*p);
      withNamedCharRef(&c, 1, loc);
      for (++p, --n; n > 0; ++p, --n)
	os().put(Char(*p));
    }
  }
  os() << delim;
}

void CopyEventHandler::entityRef(const EntityOrigin *origin)
{
  const Markup *m = origin->markup();
  if (!m)
    return;
  MarkupIter iter(*m);
  if (iter.valid()) {
    iter.advance();
    if (iter.valid()
	&& iter.type() == Markup::shortref
	&& (normalizeFlags_ & normalizeShortref)) {
       handleChange();
       Boolean containsRE = 0;
       Boolean containsRS = 0;
       for (size_t i = 0; i < iter.charsLength(); i++) {
	 Char c = iter.charsPointer()[i];
	 if (c == syntax_->standardFunction(Syntax::fRE))
	   containsRE = 1;
	 else if (c == syntax_->standardFunction(Syntax::fRS))
	   containsRS = 1;
       }
       if (containsRS)
	 os().put(syntax_->standardFunction(Syntax::fRS));
       os() << syntax_->delimGeneral(Syntax::dERO)
	 << origin->entity()->name();
       if (containsRE)
	 os().put(syntax_->standardFunction(Syntax::fRE));
       else
	 os() << syntax_->delimGeneral(Syntax::dREFC);
       return;
     }
  }
  outputMarkup(origin->parent(), *m);
}

const StringC &CopyEventHandler::elementTypeOrigName(const ElementType *type,
						     StringC &buf)
{
  if (type->index() < elementTypeOrigNames_.size()
      && elementTypeOrigNames_[type->index()].size() > 0)
    return elementTypeOrigNames_[type->index()];
  else
    return generalName(type->name(), buf);
}

const StringC &CopyEventHandler::generalName(const StringC &name,
					     StringC &buf)
{
  if ((normalizeFlags_ & normalizeLower)
      && syntax_->namecaseGeneral())
    return lowerCaseName(name, buf);
  else
    return name;
}

const StringC &CopyEventHandler::entityName(const StringC &name,
					    StringC &buf)
{
  if ((normalizeFlags_ & normalizeLower)
      && syntax_->namecaseEntity())
    return lowerCaseName(name, buf);
  else
    return name;
}

const StringC &CopyEventHandler::lowerCaseName(const StringC &name,
					       StringC &buf)
{
  size_t i;
  for (i = 0; i < name.size(); i++) {
    Char c = lowerSubst_[name[i]];
    if (c != name[i]) {
      buf = name;
      buf[i] = c;
      for (i++; i < name.size(); i++)
	lowerSubst_.subst(buf[i]);
      return buf;
    }
  }
  return name;
}

void CopyEventHandler::handleChange()
{
  if (os_ != topOs_) {
    os_ = topOs_;
    for (size_t i = 0; i < entityStack_.size(); i++) {
      StringC tem;
      entityStack_[i].str.flush();
      entityStack_[i].str.extractString(tem);
      os() << tem;
    }
    entityStack_.resize(0);
  }
}

#ifdef SP_NAMESPACE
}
#endif