actual/packages/node-libofx/OpenSP-1.5.2/nsgmls/RastEventHandler.cxx

// Copyright (c) 1994,1995 James Clark
// See the file COPYING for copying permission.

#ifdef __GNUG__
#pragma implementation
#endif

#include "config.h"
#include "RastEventHandler.h"
#include "SgmlParser.h"
#include "ParserOptions.h"
#include "Entity.h"
#include "Notation.h"
#include "Attribute.h"
#include "Vector.h"
#include "Vector.h"
#include "MessageArg.h"

#include "RastEventHandlerMessages.h"

#include <stdlib.h>
#include <string.h>

// This is based on ISO/IEC 13673, Intermediate Editor's Draft, 1994/8/29,
// together with editing instructions in ISO/IEC JTC1/SC18/WG8 N1777.

#ifdef SP_NAMESPACE
namespace SP_NAMESPACE {
#endif

const OutputCharStream::Newline nl = OutputCharStream::newline;

class EventHandlerMessenger : public Messenger {
public:
  EventHandlerMessenger(EventHandler *eh) : eh_(eh) { }
  void dispatchMessage(const Message &message) {
    eh_->message(new MessageEvent(message));
  }
  void dispatchMessage(Message &message) {
    eh_->message(new MessageEvent(message));
  }
private:
  EventHandler *eh_;
};

#if 0
const 
#endif
RastPrintable RastEventHandler::printable;

RastPrintable::RastPrintable()
{
  static const char s[] =
    " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
  size_t i;
  for (i = 0; i < sizeof(v_); i++)
    v_[i] = 0;
  for (i = 0; s[i] != '\0'; i++)
    v_[(unsigned char)s[i]] = 32 + i;
}

// inline
void RastEventHandler::flushLine(LineType type)
{
  if (lineLength_ > 0) {
    os() << char(type) << nl;
    lineLength_ = 0;
  }
}

RastSubdocState::RastSubdocState()
{
  init(0, 0);
}

RastSubdocState::RastSubdocState(SgmlParser *parser, RastEventHandler *rast)
{
  init(parser, rast);
}

void RastSubdocState::init(SgmlParser *parser, RastEventHandler *rast)
{
  parser_ = parser;
  hadActiveLpdOrDtd_ = 0;
  activeLinkTypes_.clear();
  hadDocumentElement_ = 0;
  linkProcess_.clear();
  linkProcess_.setHandler(rast);
  haveLinkProcess_ = 0;
  endPrologEvent_.clear();
  parseSubdocQueue_.clear();
  linkRuleQueue_.clear();
  for (int i = 0; i < nAttributeType; i++)
    attributeSortOrder_[i].clear();
}

void RastSubdocState::swap(RastSubdocState &to)
{
  {
    SgmlParser *tem = to.parser_;
    to.parser_ = parser_;
    parser_ = tem;
  }
  {
    Boolean tem = to.hadActiveLpdOrDtd_;
    to.hadActiveLpdOrDtd_ = hadActiveLpdOrDtd_;
    hadActiveLpdOrDtd_ = tem;
  }
  {
    Boolean tem = to.hadDocumentElement_;
    to.hadDocumentElement_ = hadDocumentElement_;
    hadDocumentElement_ = tem;
  }
  activeLpdOrDtdLocation_.swap(to.activeLpdOrDtdLocation_);
  activeLinkTypes_.swap(to.activeLinkTypes_);
  linkProcess_.swap(to.linkProcess_);
  endPrologEvent_.swap(to.endPrologEvent_);
  parseSubdocQueue_.swap(to.parseSubdocQueue_);
  linkRuleQueue_.swap(to.linkRuleQueue_);
  for (int i = 0; i < nAttributeType; i++)
    attributeSortOrder_[i].swap(to.attributeSortOrder_[i]);
}

RastEventHandler::RastEventHandler(SgmlParser *parser, Messenger *mgr)
: lineLength_(0),
  os_(0),
  piErrorCount_(0),
  RastSubdocState(parser, this),
  mgr_(mgr)
{
  RastSubdocState::init(parser, this);
}

void RastEventHandler::end()
{
  if (errorCount() != 0) {
    truncateOutput();
    os() << (piErrorCount_ != 0
	     ? "#RAST-PI-ERROR"
	     : "#ERROR")
         << nl;
  }
}

void RastEventHandler::truncateOutput()
{
  // This must be handled by derived classes to get conforming output.
}

void RastEventHandler::sgmlDecl(SgmlDeclEvent *event)
{
  rastParseSubdocYesString_ = event->sd().execToInternal("rast-parse-subdoc:yes");
  rastParseSubdocNoString_ = event->sd().execToInternal("rast-parse-subdoc:no");
  rastActiveLpdString_ = event->sd().execToInternal("rast-active-lpd:");
  rastLinkRuleString_ = event->sd().execToInternal("rast-link-rule:");
  delete event;
}

void RastEventHandler::startElement(StartElementEvent *event)
{
  flushLine(dataLine);
  if (!hadDocumentElement_) {
    if (activeLinkTypes_.size() > 0) {
      activeLinks();
      simpleLinkInfo();
    }
    hadDocumentElement_ = 1;
  }
  os() << '[' << event->name();
  Boolean hadNewline;
  if (event->attributes().size() > 0) {
    hadNewline = 1;
    os() << nl;
    attributeInfo(event->attributes(), dtdAttribute);
  }
  else
    hadNewline = 0;
  if (haveLinkProcess_) {
    const AttributeList *linkAttributes;
    const ResultElementSpec *resultElementSpec;
    EventHandlerMessenger messenger(this);
    linkProcess_.startElement(event->elementType(),
			      event->attributes(),
			      event->location(),
			      messenger,
			      linkAttributes,
			      resultElementSpec);
    if (linkProcess_.nImpliedLinkRules() > 0) {
      if (!hadNewline) {
	os() << nl;
	hadNewline = 1;
      }
      os() << "#LINK-SET-INFO" << nl;
      impliedSourceLinkRules();
    }
    if (linkAttributes) {
      if (!hadNewline) {
	os() << nl;
	hadNewline = 1;
      }
      os() << "#LINK-RULE" << nl;
      attributeInfo(*linkAttributes, linkAttribute);
      if (linkProcess_.isExplicit()) {
	os() << "#RESULT=";
	if (resultElementSpec && resultElementSpec->elementType) {
	  os() << resultElementSpec->elementType->name() << nl;
	  attributeInfo(resultElementSpec->attributeList, resultAttribute);
	}
	else
	  os() << "#IMPLIED" << nl;
      }
    }
    else
      hadNewline = 0;
  }
  os() << ']' << nl;
  delete event;
}

void RastEventHandler::activeLinks()
{
  for (size_t i = 0; i < activeLinkTypes_.size(); i++) {
    os() << "#ACTIVE-LINK=" << activeLinkTypes_[i] << nl;
    Boolean found = 0;
    if (haveLinkProcess_ && linkProcess_.name() == activeLinkTypes_[i]) {
      found = 1;
      if (linkProcess_.nImpliedLinkRules() > 0) {
	os() << "#INITIAL" << nl;
	impliedSourceLinkRules();
      }
    }
    if (!found) {
      if (endPrologEvent_) {
	for (size_t j = 0; j < endPrologEvent_->simpleLinkNames().size(); j++)
	  if (endPrologEvent_->simpleLinkNames()[j] == activeLinkTypes_[i]) {
	    found = 1;
	    break;
	  }
      }
      if (!found) {
	setNextLocation(activeLpdOrDtdLocation_);
	Messenger::message(RastEventHandlerMessages::invalidActiveLinkType,
			   StringMessageArg(activeLinkTypes_[i]));
      }
    }
    os() << "#END-ACTIVE-LINK" << nl;
  }
}

void RastEventHandler::simpleLinkInfo()
{
  if (!endPrologEvent_)
    return;
  for (size_t i = 0; i < activeLinkTypes_.size(); i++) {
    for (size_t j = 0; j < endPrologEvent_->simpleLinkNames().size(); j++) {
      const StringC &name = endPrologEvent_->simpleLinkNames()[j];
      if (name == activeLinkTypes_[i]) {
	os() << "#SIMPLE-LINK=" << name << nl;
	if (endPrologEvent_->simpleLinkAttributes()[j].size() > 0)
	  attributeInfo(endPrologEvent_->simpleLinkAttributes()[j],
			simpleAttribute);
	os() << "#END-SIMPLE-LINK" << nl;
	break;
      }
    }
  }
}

void RastEventHandler::impliedSourceLinkRules()
{
  size_t n = linkProcess_.nImpliedLinkRules();
  Vector<size_t> sortOrder(n);
  size_t i;
  for (i = 0; i < n; i++)
    sortOrder[i] = i;
  for (i = 1; i < n; i++) {
    size_t tem = sortOrder[i];
    const StringC &name
      = linkProcess_.impliedLinkRule(tem).elementType->name();
    size_t j;
    for (j = i; j > 0; j--) {
      if (lexCmp(linkProcess_.impliedLinkRule(j - 1).elementType->name(),
		 name) <= 0)
	break;
      sortOrder[j] = sortOrder[j - 1];
    }
    sortOrder[j] = tem;
  }
  for (i = 0; i < n; i++) {
    const ResultElementSpec &result
      = linkProcess_.impliedLinkRule(sortOrder[i]);
    os() << '[' << result.elementType->name();
    if (result.attributeList.size() > 0) {
      os() << nl;
      attributeInfo(result.attributeList, resultAttribute);
    }
    os() << ']' << nl;
  }
}

void RastEventHandler::endElement(EndElementEvent *event)
{
  if (haveLinkProcess_)
    linkProcess_.endElement();
  flushLine(dataLine);
  os() << "[/" << event->name() << ']' << nl;
  if (haveLinkProcess_ && linkProcess_.nImpliedLinkRules() > 0) {
    os() << "#LINK-SET-INFO" << nl;
    impliedSourceLinkRules();
    os() << "#END-LINK-SET-INFO" << nl;
  }
  delete event;
}

void RastEventHandler::data(DataEvent *event)
{
  lines(dataLine, event->data(), event->dataLength());
  delete event;
}

void RastEventHandler::pi(PiEvent *event)
{
  flushLine(dataLine);
  os() << "[?";
  size_t dataLength = event->dataLength();
  if (dataLength > 0) {
    const Char *data = event->data();
    if (dataLength >= 4
	&& memcmp(data,
		  rastParseSubdocYesString_.data(),
		  4*sizeof(Char)) == 0
	&& !interpretRastPi(data, dataLength, event->location())) {
      setNextLocation(event->location());
      Messenger::message(RastEventHandlerMessages::invalidRastPiError);
    }
    os() << nl;
    lines(dataLine, event->data(), dataLength);
    flushLine(dataLine);
  }
  os() << ']' << nl;
  delete event;
}

inline
Boolean equal(const Char *s1, size_t n1, const StringC &s2)
{
  return (n1 == s2.size()
	  && (n1 == 0
	      || memcmp(s1, s2.data(), n1*sizeof(Char)) == 0));
}

// Is s2 a prefix of s1 of length n1?

inline
Boolean prefix(const Char *s1, size_t n1, const StringC &s2)
{
  return (n1 >= s2.size()
	  && (n1 == 0
	      || memcmp(s1, s2.data(), s2.size()*sizeof(Char)) == 0));
}

Boolean RastEventHandler::interpretRastPi(const Char *data,
					  size_t dataLength,
					  const Location &loc)
{
  if (equal(data, dataLength, rastParseSubdocNoString_)) {
    queueParseSubdoc(0);
    return 1;
  }
  if (equal(data, dataLength, rastParseSubdocYesString_)) {
    queueParseSubdoc(1);
    return 1;
  }
  if (prefix(data, dataLength, rastActiveLpdString_)) {
    if (hadActiveLpdOrDtd_)
      return 1;
    hadActiveLpdOrDtd_ = 1;
    activeLpdOrDtdLocation_ = loc;
    const Char *p = data + rastActiveLpdString_.size();
    size_t n = dataLength - rastActiveLpdString_.size();
    StringC name;
    for (;;) {
      if (n == 0 || *p == ',') {
	if (name.size() == 0)
	  return 0;
	for (size_t i = 0; i < activeLinkTypes_.size(); i++)
	  if (name == activeLinkTypes_[i]) {
	    setNextLocation(activeLpdOrDtdLocation_);
	    Messenger::message(RastEventHandlerMessages::duplicateActiveLinkType,
			       StringMessageArg(name));
	  }
	activeLinkTypes_.resize(activeLinkTypes_.size() + 1);
	name.swap(activeLinkTypes_.back());
	if (n == 0)
	  break;
      }
      else
	name += *p;
      p++;
      n--;
    }
    for (size_t i = 0; i < activeLinkTypes_.size(); i++)
      parser_->activateLinkType(activeLinkTypes_[i]);
    return 1;
  }
  if (prefix(data, dataLength, rastLinkRuleString_)) {
    LinkRulePi *p = new LinkRulePi;
    p->pi.assign(data + rastLinkRuleString_.size(),
		 dataLength - rastLinkRuleString_.size());
    p->loc = loc;
    linkRuleQueue_.append(p);
    return 1;
  }
  return 0;
}

void RastEventHandler::sdataEntity(SdataEntityEvent *event)
{
  flushLine(dataLine);
  os() << "#SDATA-TEXT" << nl;
  lines(markupLine, event->data(), event->dataLength());
  flushLine(markupLine);
  os() << "#END-SDATA" << nl;
  delete event;
}

void RastEventHandler::externalDataEntity(ExternalDataEntityEvent *event)
{
  const ExternalDataEntity *entity = event->entity();
  if (!entity)
    return;
  flushLine(dataLine);
  os() << "[&" << entity->name() << nl;
  externalEntityInfo(entity, dtdAttribute);
  os() << ']' << nl;
  delete event;
}

void RastEventHandler::externalEntityInfo(const ExternalDataEntity *entity,
					  AttributeType attributeType)
{
  char c;
  switch (entity->dataType()) {
  case Entity::cdata:
    c = 'C';
    break;
  case Entity::sdata:
    c = 'S';
    break;
  case Entity::ndata:
    c = 'N';
    break;
  default:
    return;
  }
  os() << '#' << c << "DATA-EXTERNAL" << nl;
  externalIdInfo(entity->externalId());
  os() << "#NOTATION=" << entity->notation()->name() << nl;
  externalIdInfo(entity->notation()->externalId());
  attributeInfo(entity->attributes(),
		(attributeType == resultAttribute
		 ? resultAttribute
		 : dtdAttribute));
}

void RastEventHandler::subdocEntity(SubdocEntityEvent *event)
{
  const SubdocEntity *entity = event->entity();
  if (!entity)
    return;
  flushLine(dataLine);
  os() << "[&" << entity->name() << nl;
  Ptr<InputSourceOrigin> origin(event->entityOrigin()->copy());
  subdocEntityInfo(entity, origin, 1);
  os() << ']' << nl;
  delete event;
}

void RastEventHandler::subdocEntityInfo(const SubdocEntity *entity,
					const Ptr<InputSourceOrigin> &entityOrigin,
					Boolean referenced)
{
  os() << "#SUBDOC" << nl;
  externalIdInfo(entity->externalId());
  if (parseNextSubdoc()) {
    // FIXME subdocuments in entity attributes shouldn't count against
    // SUBDOC quantity limit.
    os() << "#PARSED-SUBDOCUMENT" << nl;
    SgmlParser::Params params;
    params.entityType = SgmlParser::Params::subdoc;
    params.subdocInheritActiveLinkTypes = 0;
    params.subdocReferenced = referenced;
    params.parent = parser_;
    params.sysid = entity->externalId().effectiveSystemId();
    params.origin = entityOrigin;
    SgmlParser parser(params);
    RastSubdocState oldSubdocState;
    RastSubdocState::swap(oldSubdocState);
    RastSubdocState::init(&parser, this);
    parser.parseAll(*this);
    oldSubdocState.swap(*this);
  }
}

void RastEventHandler::queueParseSubdoc(Boolean parseSubdoc)
{
  parseSubdocQueue_.push_back(PackedBoolean(parseSubdoc));
}

Boolean RastEventHandler::parseNextSubdoc()
{
  if (parseSubdocQueue_.size() == 0)
    return 0;
  Boolean result = parseSubdocQueue_[0];
  if (parseSubdocQueue_.size() > 1) {
    for (size_t i = 1; i < parseSubdocQueue_.size(); i++)
      parseSubdocQueue_[i - 1] = parseSubdocQueue_[i];
  }
  parseSubdocQueue_.resize(parseSubdocQueue_.size() - 1);
  return result;
}


void RastEventHandler::externalIdInfo(const ExternalId &id)
{
  const StringC *systemId = id.systemIdString();
  const StringC *publicId = id.publicIdString();
  if (publicId) {
    os() << "#PUBLIC" << nl;
    if (publicId->size() == 0)
      os() << "#EMPTY" << nl;
    else {
      lines(markupLine, publicId->data(), publicId->size());
      flushLine(markupLine);
    }
  }
  if (systemId || !publicId) {
    os() << "#SYSTEM" << nl;
    if (!systemId)
      os() << "#NONE" << nl;
    else if (systemId->size() == 0)
      os() << "#EMPTY" << nl;
    else {
      lines(markupLine, systemId->data(), systemId->size());
      flushLine(markupLine);
    }
  }
}

void RastEventHandler::nonSgmlChar(NonSgmlCharEvent *event)
{
  flushLine(dataLine);
  os() <<'#' << (unsigned long)event->character() << nl;
  delete event;
}

void RastEventHandler::lines(LineType type, const Char *p, size_t length)
{
  // This needs to be fast.
  while (length != 0) {
    if (printable(*p)) {
      size_t lim;
      switch (lineLength_) {
      case maxLineLength:
	os() << char(type) << nl;
	lineLength_ = 0;
	// fall through
      case 0:
	os() << char(type);
	lim = maxLineLength;
	break;
      default:
	lim = maxLineLength - lineLength_;
	break;
      }
      if (lim > length)
	lim = length;
      size_t n = lim;
      for (;;) {
	os().put(*p);
	p++;
	if (--n == 0)
	  break;
	if (!printable(*p)) {
	  lim -= n;
	  break;
	}
      }
      length -= lim;
      lineLength_ += lim;
    }
    else {
      // *p is an unprintable character print it
      flushLine(type);
      switch (*p) {
      case RS:
	os() << "#RS" << nl;
	break;
      case RE:
	os() << "#RE" << nl;
	break;
      case TAB:
	os() << "#TAB" << nl;
	break;
      default:
	os() << '#' << (unsigned long)*p << nl;
	break;
      }
      p++;
      length--;
    }
  }
}

int RastEventHandler::lexCmp(const StringC &s1, const StringC &s2)
{
  const Char *p1 = s1.data();
  size_t n1 = s1.size();
  const Char *p2 = s2.data();
  size_t n2 = s2.size();
  for (;;) {
    if (n1 == 0)
      return n2 == 0 ? 0 : -1;
    if (n2 == 0)
      return 1;
    if (*p1 != *p2) {
      // printable characters precede non-printable characters;
      // printable characters are in ASCII order
      // non-printable characters are in document character set order
      int a1 = printable(*p1);
      int a2 = printable(*p2);
      if (a1 == 0) {
	if (a2 == 0)
	  return *p1 < *p2 ? -1 : 1;
	else
	  return 1;
      }
      else if (a2 == 0)
	return -1;
      else
	return a1 - a2;
    }
    p1++;
    p2++;
    n1--;
    n2--;
  }
}

void RastEventHandler::attributeInfo(const AttributeList &attributes,
				     AttributeType attributeType)
{
  size_t length = attributes.size();
  if (length == 0)
    return;
  size_t defIndex = attributes.defIndex();
  if (defIndex >= attributeSortOrder_[attributeType].size())
    attributeSortOrder_[attributeType].resize(defIndex + 1);
  Vector<size_t> &sortOrder = attributeSortOrder_[attributeType][defIndex];
  if (sortOrder.size() != length
      || attributeType == simpleAttribute) {
    sortOrder.resize(length);
    size_t i;
    for (i = 0; i < length; i++)
      sortOrder[i] = i;
    // insertion sort
    for (i = 1; i < length; i++) {
      size_t tem = sortOrder[i];
      size_t j;
      for (j = i; j > 0; j--) {
	if (lexCmp(attributes.name(sortOrder[j - 1]),
		   attributes.name(tem)) <= 0)
	  break;
	sortOrder[j] = sortOrder[j - 1];
      }
      sortOrder[j] = tem;
    }
  }
  for (size_t j = 0; j < length; j++) {
    // Don't use sortOrder because attributeSortOrder_ may be grown
    // because of data attributes.
    size_t i = attributeSortOrder_[attributeType][defIndex][j];
    os() << attributes.name(i) << '=' << nl;
    const Text *text;
    const StringC *string;
    const AttributeValue *value = attributes.value(i);
    if (value) {
      switch (value->info(text, string)) {
      case AttributeValue::implied:
	os() << "#IMPLIED" << nl;
	break;
      case AttributeValue::tokenized:
	lines(markupLine, string->data(), string->size());
	flushLine(markupLine);
	break;
      case AttributeValue::cdata:
	{
	  TextIter iter(*text);
	  TextItem::Type type;
	  const Char *p;
	  size_t length;
	  const Location *loc;
	  while (iter.next(type, p, length, loc))
	    switch (type) {
	    case TextItem::data:
	    case TextItem::cdata:
	      lines(markupLine, p, length);
	      break;
	    case TextItem::sdata:
	      flushLine(markupLine);
	      os() << "#SDATA-TEXT" << nl;
	      lines(markupLine, p, length);
	      flushLine(markupLine);
	      os() << "#END-SDATA" << nl;
	      break;
	    case TextItem::nonSgml:
	      flushLine(markupLine);
	      os() << '#' << (unsigned long)*p << nl;
	      break;
	    default:
	      break;
	    }
	  flushLine(markupLine);
	}
	break;
      }
    }
    const AttributeSemantics *semantics = attributes.semantics(i);
    if (semantics) {
      ConstPtr<Notation> notation
	= semantics->notation();
      if (!notation.isNull())
	externalIdInfo(notation->externalId());
      size_t nEntities = semantics->nEntities();
      for (size_t i = 0; i < nEntities; i++) {
	ConstPtr<Entity> entity
	  = semantics->entity(i);
	if (!entity.isNull()) {
	  const ExternalDataEntity *externalDataEntity
	    = entity->asExternalDataEntity();
	  if (externalDataEntity)
	    externalEntityInfo(externalDataEntity,
			       (attributeType == resultAttribute
				? resultAttribute
				: dtdAttribute));
	  else {
	    const SubdocEntity *subdocEntity = entity->asSubdocEntity();
	    if (subdocEntity) {
	      Ptr<InputSourceOrigin> entityOrigin
		= EntityOrigin::make(entity,
				     ((TokenizedAttributeValue *)value)
				     ->tokenLocation(i));
	      subdocEntityInfo(subdocEntity, entityOrigin, 0);
	    }
	    else {
	      const InternalEntity *internalEntity = entity->asInternalEntity();
	      if (internalEntity)
		internalEntityInfo(internalEntity);
	    }
	  }
	}
	os() << "#END-ENTITY" << nl;
      }
    }
  }
}

void RastEventHandler::internalEntityInfo(const InternalEntity *entity)
{
  if (!entity)
    return;
  os() << '#'
       << char(entity->dataType() == Entity::cdata ? 'C' : 'S')
       << "DATA-INTERNAL" << nl;
  const StringC &str = entity->string();
  lines(markupLine, str.data(), str.size());
  flushLine(markupLine);
}

void RastEventHandler::endProlog(EndPrologEvent *event)
{
  if (!event->lpdPointer().isNull()) {
    linkProcess_.init(event->lpdPointer());
    haveLinkProcess_ = 1;
  }
  if (event->simpleLinkNames().size() > 0)
    endPrologEvent_ = event;
  else
    delete event;
}

void RastEventHandler::uselink(UselinkEvent *event)
{
  linkProcess_.uselink(event->linkSet(),
		       event->restore(),
		       event->lpd().pointer());
  if (haveLinkProcess_ && linkProcess_.nImpliedLinkRules() > 0) {
    flushLine(dataLine);
    os() << "#LINK-SET-INFO" << nl;
    impliedSourceLinkRules();
    os() << "#END-LINK-SET-INFO" << nl;
  }
  delete event;
}

void RastEventHandler::initMessage(Message &msg)
{
  mgr_->initMessage(msg);
}

void RastEventHandler::dispatchMessage(const Message &msg)
{
  if (msg.isError())
    piErrorCount_++;
  if (!cancelled()) {
    noteMessage(msg);
    mgr_->dispatchMessage(msg);
  }
}

RastLinkProcess::RastLinkProcess()
: rast_(0)
{
}

void RastLinkProcess::setHandler(RastEventHandler *rast)
{
  rast_ = rast;
}

// Always return 1. 0 means not ready.

Boolean RastLinkProcess::selectLinkRule(const Vector<const AttributeList *> &linkAttributes,
					const Location &location,
					size_t &selected)
{
  if (!rast_->linkRuleQueue_.empty()) {
    LinkRulePi *p = rast_->linkRuleQueue_.get();
    if (!selectLinkRulePi(p->pi, p->loc, linkAttributes, selected))
      selected = 0;
  }
  else {
    if (linkAttributes.size() > 0) {
      rast_->setNextLocation(location);
      rast_->Messenger::message(RastEventHandlerMessages::multipleLinkRules);
    }
    selected = 0;
  }
  return 1;
}

// Return zero for failure (RAST-PI-ERROR).

Boolean RastLinkProcess::selectLinkRulePi(const StringC &value,
					  const Location &loc,
					  const Vector<const AttributeList *> &linkAttributes,
					  size_t &selected)
{
  Boolean haveSelection = 0;
  size_t i;
  for (i = 0; i < linkAttributes.size(); i++) {
    const AttributeList &a = *linkAttributes[i];
    Boolean matchValue = 0;
    for (size_t j = 0; j < a.size(); j++) {
      const Text *textp;
      const StringC *strp;
      switch (a.value(j)->info(textp, strp)) {
      case AttributeValue::cdata:
	// What if it contains SDATA entities?
	if (textp->string() == value)
	  matchValue = 1;
	break;
      case AttributeValue::tokenized:
	if (*strp == value)
	  matchValue = 1;
	break;
      default:
	break;
      }
      if (matchValue)
	break;
    }
    if (matchValue) {
      if (haveSelection) {
	rast_->setNextLocation(loc);
	rast_->Messenger::message(RastEventHandlerMessages::multipleLinkRuleMatch);
	return 0;
      }
      haveSelection = 1;
      selected = i;
    }
  }
  if (!haveSelection) {
    rast_->setNextLocation(loc);
    rast_->Messenger::message(RastEventHandlerMessages::noLinkRuleMatch);
    return 0;
  }
  return 1;
}

void RastLinkProcess::swap(RastLinkProcess &to)
{
  LinkProcess::swap(to);
  RastEventHandler *tem = to.rast_;
  to.rast_ = rast_;
  rast_ = tem;
}

#ifdef SP_NAMESPACE
}
#endif