parseMode.cxx revision 7c478bd95313f5f23a4c958a745db2134aa03244
// Copyright (c) 1994 James Clark
// See the file COPYING for copying permission.
#pragma ident "%Z%%M% %I% %E% SMI"
#include "splib.h"
#include "Parser.h"
#include "ParserMessages.h"
#include "MessageArg.h"
#include "TokenMessageArg.h"
#include "ModeInfo.h"
#include "Partition.h"
#include "SrInfo.h"
#include "Vector.h"
#include "ISetIter.h"
#include "token.h"
#include "TrieBuilder.h"
#include "macros.h"
#ifdef SP_NAMESPACE
namespace SP_NAMESPACE {
#endif
enum {
modeUsedInSd = 01,
modeUsedInProlog = 02,
modeUsedInInstance = 04,
modeUsesSr = 010
};
static struct {
unsigned flags;
} modeTable[] = {
{ mdMinusMode, modeUsedInProlog },
{ mdPeroMode, modeUsedInProlog },
{ sdMode, modeUsedInSd },
{ sdcomMode, modeUsedInSd },
{ proMode, modeUsedInProlog },
{ dsMode, modeUsedInProlog },
{ dsiMode, modeUsedInProlog },
{ plitMode, modeUsedInProlog },
{ plitaMode, modeUsedInProlog },
{ pliteMode, modeUsedInProlog },
{ sdplitMode, modeUsedInSd },
{ sdplitaMode, modeUsedInSd },
{ grpsufMode, modeUsedInProlog },
{ asMode, modeUsedInProlog },
{ slitMode, modeUsedInProlog },
{ slitaMode, modeUsedInProlog },
{ sdslitMode, modeUsedInSd },
{ sdslitaMode, modeUsedInSd },
{ cconMode, modeUsedInInstance },
{ rcconMode, modeUsedInInstance },
{ rcconeMode, modeUsedInInstance },
{ tagMode, modeUsedInInstance },
};
void Parser::compileSdModes()
{
int n = 0;
compileModes(modes, n, 0);
}
void Parser::compilePrologModes()
{
int n = 0;
if (scopeInstance) {
}
else if (haveSr) {
}
else {
}
}
compileModes(modes, n, 0);
}
void Parser::compileInstanceModes()
{
return;
int n = 0;
if (scopeInstance) {
}
else {
}
}
}
int n,
{
int i;
Boolean includesShortref = 0;
sets[i] = 0;
for (i = 0; i < Syntax::nDelimGeneral; i++)
delims[i] = 0;
for (i = 0; i < 3; i++)
functions[i] = 0;
for (i = 0; i < n; i++) {
break;
case TokenInfo::delimDelimType:
break;
case TokenInfo::delimSetType:
// fall through
break;
case TokenInfo::functionType:
break;
}
}
includesShortref = 1;
}
for (i = 0; i < 3; i++)
if (functions[i])
for (i = 0; i < Syntax::nDelimGeneral; i++)
if (delims[i]) {
}
if (includesShortref && dtd) {
for (size_t i = 0; i < n; i++) {
else
}
}
int usedSets = 0;
if (sets[i])
int nCodes = 0;
if (sets[i])
for (i = 0; i < Syntax::nDelimGeneral; i++)
if (delims[i]) {
}
for (i = 0; i < 3; i++)
if (functions[i])
int nShortref;
if (!includesShortref || !dtd)
nShortref = 0;
else {
for (i = 0; i < nShortref; i++) {
size_t j;
break;
}
p->bSequenceLength = 1;
break;
p->bSequenceLength += 1;
}
}
else
p->bSequenceLength = 0;
}
}
if (options().warnDataDelim) {
case TokenInfo::delimDelimType:
case TokenInfo::delimSetType:
{
break;
break;
for (size_t i = 0; ; i++) {
if (i >= dataDelimCodes.size()) {
dataDelimCodes += c;
break;
}
if (dataDelimCodes[i] == c)
break;
}
}
break;
default:
break;
}
}
}
for (i = 0; i < n; i++) {
if (multicode) {
}
// We try to handle the possibility that some delimiters may be empty;
// this might happen when compiling recognizers for the SGML declaration.
break;
case TokenInfo::delimDelimType:
{
}
}
break;
case TokenInfo::delimSetType:
break;
if (multicode) {
}
break;
case TokenInfo::functionType:
if (multicode)
break;
}
}
if (iter.includesShortref()) {
for (int j = 0; j < nShortref; j++) {
if (p->bSequenceLength > 0)
p->chars2, tokenFirstShortref + j,
else
}
}
if (options().warnDataDelim) {
switch (modes[i]) {
default:
if (!iter.includesShortref())
break;
// fall through
case alitMode:
case alitaMode:
case aliteMode:
case talitMode:
case talitaMode:
case taliteMode:
code += dataDelimCodes[j];
}
break;
case plitMode:
case plitaMode:
case pliteMode:
{
}
break;
}
}
setRecognizer(modes[i],
// FIXME give more information
sdPointer()),
sdPointer()));
}
}
void Parser::compileNormalMap()
{
case TokenInfo::delimDelimType:
case TokenInfo::delimSetType:
{
break;
}
break;
}
break;
case TokenInfo::functionType:
break;
}
}
for (int i = 0; i < nShortref; i++) {
}
else {
}
}
}
{
if (!syntax.hasShortrefs())
return;
size_t i;
for (i = 0; i < Syntax::nDelimGeneral; i++)
delimRelevant[i] = 0;
case TokenInfo::delimDelimType:
case TokenInfo::delimSetType:
break;
default:
break;
}
}
// PIO and NET are the only delimiters that are recognized in con
// mode without context. If a short reference delimiter is
// identical to one of these delimiters, then we'll have an
// ambiguity. We make such a short reference delimiter needed
// to ensure that this ambiguity is reported.
// A short reference delimiter is needed if it is used or if it can
// contains some other shorter delimiter that is either a relevant general
// delimiter or a shortref delimiter that is used.
for (i = 0; i < nShortrefComplex; i++) {
size_t j;
for (j = 0; j < Syntax::nDelimGeneral; j++)
if (delimRelevant[j]
syntax.delimGeneral(j),
0,
syntax)) {
break;
}
1,
syntax)) {
break;
}
}
}
const StringC &d,
{
size_t j = 0;
size_t k = i;
for (;;) {
if (j == d.size())
return 1;
break;
j++;
k++;
}
j++;
k++;
// it was the last B in the sequence
j++;
}
}
else
break;
}
++j;
++k;
k++;
}
}
else
break;
}
else if (d[j] == sr[k]) {
j++;
k++;
}
else
break;
}
}
return 0;
}
#ifdef SP_NAMESPACE
}
#endif