131 lines
3.3 KiB
C++
131 lines
3.3 KiB
C++
// Copyright (c) 1994 James Clark
|
|
// See the file COPYING for copying permission.
|
|
|
|
#ifdef __GNUG__
|
|
#pragma implementation
|
|
#endif
|
|
#include "splib.h"
|
|
#include "OutputState.h"
|
|
#include "Event.h"
|
|
#include "Allocator.h"
|
|
|
|
#ifdef SP_NAMESPACE
|
|
namespace SP_NAMESPACE {
|
|
#endif
|
|
|
|
OutputState::OutputState()
|
|
{
|
|
init();
|
|
}
|
|
|
|
void OutputState::init()
|
|
{
|
|
nextSerial_ = 0;
|
|
stack_.clear();
|
|
stack_.insert(new OutputStateLevel);
|
|
}
|
|
|
|
OutputStateLevel::OutputStateLevel()
|
|
: state(OutputState::afterStartTag)
|
|
{
|
|
}
|
|
|
|
void OutputState::handleRe(EventHandler &handler, Allocator &alloc,
|
|
const EventsWanted &eventsWanted, Char re,
|
|
const Location &location)
|
|
{
|
|
re_ = re;
|
|
if (eventsWanted.wantInstanceMarkup())
|
|
handler.reOrigin(new (alloc) ReOriginEvent(re_, location, nextSerial_));
|
|
switch (top().state) {
|
|
case afterStartTag:
|
|
// it's the first RE in the element
|
|
if (eventsWanted.wantInstanceMarkup())
|
|
handler.ignoredRe(new (alloc) IgnoredReEvent(re_, location, nextSerial_++));
|
|
top().state = afterRsOrRe;
|
|
break;
|
|
case afterRsOrRe:
|
|
case afterData:
|
|
top().state = pendingAfterRsOrRe;
|
|
top().reLocation = location;
|
|
top().reSerial = nextSerial_++;
|
|
break;
|
|
case pendingAfterRsOrRe:
|
|
// We now know that the pending RE won't be ignored as the last RE.
|
|
handler.data(new (alloc) ReEvent(&re_, top().reLocation, top().reSerial));
|
|
top().state = pendingAfterRsOrRe;
|
|
top().reLocation = location;
|
|
top().reSerial = nextSerial_++;
|
|
break;
|
|
case pendingAfterMarkup:
|
|
// We've had only markup since the last RS or RE, so this
|
|
// RE is ignored. Note that it's this RE that's ignored, not
|
|
// the pending one.
|
|
if (eventsWanted.wantInstanceMarkup())
|
|
handler.ignoredRe(new (alloc) IgnoredReEvent(re_, location, nextSerial_++));
|
|
top().state = pendingAfterRsOrRe;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OutputState::noteRs(EventHandler &, Allocator &, const EventsWanted &)
|
|
{
|
|
if (top().hasPendingRe())
|
|
top().state = pendingAfterRsOrRe;
|
|
else
|
|
top().state = afterRsOrRe;
|
|
}
|
|
|
|
void OutputState::noteMarkup(EventHandler &, Allocator &, const EventsWanted &)
|
|
{
|
|
switch (top().state) {
|
|
case afterRsOrRe:
|
|
top().state = afterStartTag;
|
|
break;
|
|
case pendingAfterRsOrRe:
|
|
top().state = pendingAfterMarkup;
|
|
break;
|
|
default:
|
|
break; // avoid warning
|
|
}
|
|
}
|
|
|
|
void OutputState::noteData(EventHandler &handler, Allocator &alloc,
|
|
const EventsWanted &)
|
|
{
|
|
if (top().hasPendingRe())
|
|
handler.data(new (alloc) ReEvent(&re_, top().reLocation, top().reSerial));
|
|
top().state = afterData;
|
|
}
|
|
|
|
void OutputState::noteStartElement(Boolean included,
|
|
EventHandler &handler, Allocator &alloc,
|
|
const EventsWanted &)
|
|
{
|
|
if (included)
|
|
stack_.insert(new OutputStateLevel);
|
|
else {
|
|
if (top().hasPendingRe())
|
|
handler.data(new (alloc) ReEvent(&re_, top().reLocation, top().reSerial));
|
|
top().state = afterStartTag;
|
|
}
|
|
}
|
|
|
|
void OutputState::noteEndElement(Boolean included, EventHandler &handler,
|
|
Allocator &alloc,
|
|
const EventsWanted &eventsWanted)
|
|
{
|
|
if (eventsWanted.wantInstanceMarkup() && top().hasPendingRe())
|
|
handler.ignoredRe(new (alloc) IgnoredReEvent(re_, top().reLocation,
|
|
top().reSerial));
|
|
if (included) {
|
|
delete stack_.get();
|
|
noteMarkup(handler, alloc, eventsWanted);
|
|
}
|
|
else
|
|
top().state = afterData;
|
|
}
|
|
|
|
#ifdef SP_NAMESPACE
|
|
}
|
|
#endif
|