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