SOEntityCatalog.cxx revision 7c478bd95313f5f23a4c958a745db2134aa03244
// Copyright (c) 1994, 1995, 1996 James Clark
// See the file COPYING for copying permission.
#pragma ident "%Z%%M% %I% %E% SMI"
#ifdef __GNUG__
#pragma implementation
#endif
#include "splib.h"
#include "CharsetInfo.h"
#include "MessageArg.h"
#include "CatalogMessages.h"
#include "SOEntityCatalog.h"
#include "EntityDecl.h"
#include "EntityCatalog.h"
#include "Message.h"
#include "StringC.h"
#include "types.h"
#include "HashTable.h"
#include "InputSource.h"
#include "Boolean.h"
#include "SubstTable.h"
#include "CatalogEntry.h"
#include "Vector.h"
#include "StorageManager.h"
#include "macros.h"
#ifdef SP_NAMESPACE
namespace SP_NAMESPACE {
#endif
class CatalogParser;
class SOEntityCatalog;
class SOCatalogManagerImpl : public SOCatalogManager {
public:
const CharsetInfo *sysidCharset,
const CharsetInfo *catalogCharset,
const CharsetInfo &charset,
Messenger &) const;
private:
const CharsetInfo &charset,
const CharsetInfo *sysidCharset_;
const CharsetInfo *catalogCharset_;
};
class SOEntityCatalog : public EntityCatalog {
public:
const Syntax &,
const CharsetInfo &,
Messenger &,
StringC &) const;
const CharsetInfo &,
Messenger &,
StringC &) const;
const CharsetInfo &,
Messenger &,
UnivChar &) const;
void endCatalog();
return em_;
}
private:
void operator=(const SOEntityCatalog &); // undefined
const CharsetInfo &charset,
const StringC *lookupPublicId,
const CatalogEntry *
class Table {
public:
Table();
Boolean overrideOnly) const;
private:
void operator=(const Table &); // undefined
// These are entries that are applicable when an explicit system id
// was specified in the external identifier.
// This specifies the entries that should substitute for the
// overrideEntries_ when an explicit system identifier was not specified.
};
};
class CatalogParser : private Messenger {
public:
CatalogParser(const CharsetInfo &);
const CharsetInfo &sysidCharset,
const CharsetInfo &catalogCharset,
public:
// Since it's a return type, it has to be public to keep some
// (broken) compilers happy.
enum Param {
};
private:
enum {
data,
eof,
nul,
lit,
lita,
s,
min // other minimum data characters
};
enum { minimumLiteral = 01 };
void dispatchMessage(Message &);
void dispatchMessage(const Message &);
void initMessage(Message &);
void parsePublic();
void parseDelegate();
void parseDtddecl();
void parseSystem();
void parseOverride();
void parseName();
void skipComment();
int cat = categoryTable_[c];
}
XcharMap<unsigned char> categoryTable_;
};
const CharsetInfo *sysidCharset,
const CharsetInfo *catalogCharset,
{
return new SOCatalogManagerImpl(sysids,
}
const CharsetInfo *sysidCharset,
const CharsetInfo *catalogCharset,
{
}
{
// FIXME do catalog caching here
StringC s;
return 0;
}
}
else {
s)) {
return 0;
}
}
return 0;
}
return 1;
}
const CharsetInfo &charset,
{
size_t i;
for (i = 0; i < nSystemCatalogsMustExist_; i++)
mgr);
if (useDocCatalog_)
mgr);
return entityCatalog;
}
const CharsetInfo &charset,
{
return;
}
}
return;
}
size_t i;
for (i = 0; i < v.size(); i++)
if (v[i].storageManager->inheritable()) {
break;
}
}
}
mgr);
}
{
}
void SOEntityCatalog::endCatalog()
{
haveCurrentBase_ = 0;
}
const CharsetInfo &charset,
const StringC *lookupPublicId,
{
mgr,
result);
}
const CharsetInfo &charset,
{
const CatalogEntry *entry = 0;
const CatalogEntry *delegatedEntry = 0;
if (entity.systemIdPointer())
if (entity.publicIdPointer()) {
const CatalogEntry *publicEntry;
entity.systemIdPointer() != 0,
if (publicEntry && delegated)
// match for system id has priority over match for public id in same
// catalog
if (publicEntry
entry = publicEntry;
}
const CatalogEntry *entityEntry;
case EntityDecl::parameterEntity:
{
}
// fall through
case EntityDecl::generalEntity:
break;
default:
break;
}
if (!subst)
entity.systemIdPointer() != 0);
else
entity.systemIdPointer() != 0);
// match for public id has priority over match for entity in same
// catalog
if (entityEntry
entry = entityEntry;
}
if (entry)
: 0,
mgr,
result);
if (entity.systemIdPointer())
0,
mgr,
result);
return 0;
}
const CharsetInfo &charset,
{
return (entry
}
const CharsetInfo &charset,
{
if (!entry)
return 0;
if (delegated)
return 0; // FIXME
return 0;
UnivChar n = 0;
if (d < 0)
return 0;
n += d;
}
result = n;
return 1;
}
const CatalogEntry *
const CharsetInfo &charset,
{
const CatalogEntry *bestEntry = 0;
|| (i >= 2
if (entry
&& (!bestEntry
delegated = 1;
}
}
}
if (entry
delegated = 0;
}
return bestEntry;
}
{
}
{
}
{
}
{
}
{
}
{
? int(declType) - 1
: int(declType));
}
{
if (!haveSgmlDecl_) {
haveSgmlDecl_ = true;
sgmlDeclLoc_ = loc;
}
}
{
if (!haveDocument_) {
haveDocument_ = true;
documentLoc_ = loc;
}
}
{
haveCurrentBase_ = 0;
else {
haveCurrentBase_ = 1;
}
}
{
}
const CatalogEntry &entry,
{
if (override)
else {
if (!e)
}
}
Boolean overrideOnly) const
{
if (!overrideOnly) {
if (e)
return e;
}
}
const CatalogEntry *
Boolean overrideOnly) const
{
int nIter = 0;
if (!overrideOnly)
const CatalogEntry *entry = 0;
for (int i = 0; i < nIter; i++) {
const CatalogEntry *value;
}
}
}
return entry;
}
{
}
: categoryTable_(data),
{
static const char lcletters[] = "abcdefghijklmnopqrstuvwxyz";
static const char ucletters[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
// minimum data other than lcletter, ucletter
static const char minChars[] = "0123456789-.'()+,/:=?";
static const char sChars[] = " \n\r\t";
const char *p;
const char *q;
}
for (p = sChars; *p; p++)
for (p = minChars; *p; p++)
}
const CharsetInfo &sysidCharset,
const CharsetInfo &catalogCharset,
{
if (!in_)
return;
override_ = 0;
Boolean recovering = false;
for (;;) {
recovering = false;
if (param_ == publicKey_)
parsePublic();
else if (param_ == systemKey_)
parseSystem();
else if (param_ == entityKey_)
else if (param_ == doctypeKey_)
else if (param_ == linktypeKey_)
else if (param_ == notationKey_)
else if (param_ == sgmlDeclKey_) {
if (parseArg())
}
else if (param_ == documentKey_) {
if (parseArg())
}
else if (param_ == overrideKey_)
else if (param_ == catalogKey_) {
if (parseArg()) {
break;
}
}
if (parseArg()) {
0,
0,
mgr,
tem)) {
0,
mgr);
}
}
}
else if (param_ == delegateKey_)
else if (param_ == dtddeclKey_)
parseDtddecl();
else {
break;
recovering = true;
}
}
break;
else if (!recovering) {
recovering = true;
}
}
delete in_;
catalog->endCatalog();
}
}
{
if (!origin)
return 0;
if (!info)
return 0;
soLoc))
return 0;
for (;;) {
break;
if (!origin)
break;
if (info1) {
soLoc1)) {
return 1;
}
}
}
}
return 0;
}
void CatalogParser::parseOverride()
{
if (parseParam() != nameParam) {
return;
}
override_ = 1;
override_ = 0;
else
}
void CatalogParser::parsePublic()
{
return;
}
if (!parseArg())
return;
}
void CatalogParser::parseDelegate()
{
return;
}
if (!parseArg())
return;
}
void CatalogParser::parseDtddecl()
{
return;
}
if (!parseArg())
return;
}
void CatalogParser::parseSystem()
{
if (!parseArg())
return;
else if (parm != literalParam) {
return;
}
}
{
if (!parseArg())
return;
if (!parseArg())
return;
}
{
return false;
}
return true;
}
{
for (;;) {
switch (categoryTable_[c]) {
case eof:
return eofParam;
case lit:
case lita:
parseLiteral(c, flags);
return literalParam;
case s:
break;
case nul:
break;
case minus:
c = get();
if (c == minus_) {
skipComment();
break;
}
unget();
// fall through
default:
parseName();
return nameParam;
}
}
}
void CatalogParser::skipComment()
{
for (;;) {
if (c == minus_) {
c = get();
if (c == minus_)
break;
}
if (c == InputSource::eE) {
break;
}
}
}
{
for (;;) {
if (c == InputSource::eE) {
break;
}
break;
if (flags & minimumLiteral) {
if (!isMinimumData(c))
if (c == rs_)
;
}
}
else {
}
}
else
}
}
void CatalogParser::parseName()
{
int cat = categoryTable_[c];
break;
// FIXME maybe check for LIT or LITA
}
}
{
}
{
}
{
}
{
}
#ifdef SP_NAMESPACE
}
#endif