parsemode.cxx

SP是一个基于GNU C++编译器

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

#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 {
  Mode mode;
  unsigned flags;
} modeTable[] = {
  { grpMode, modeUsedInProlog|modeUsedInInstance },
  { alitMode, modeUsedInProlog|modeUsedInInstance },
  { alitaMode, modeUsedInProlog|modeUsedInInstance },
  { aliteMode, modeUsedInProlog|modeUsedInInstance },
  { talitMode, modeUsedInProlog|modeUsedInInstance },
  { talitaMode, modeUsedInProlog|modeUsedInInstance },
  { taliteMode, modeUsedInProlog|modeUsedInInstance },
  { mdMode, modeUsedInProlog|modeUsedInInstance },
  { mdMinusMode, modeUsedInProlog },
  { mdPeroMode, modeUsedInProlog },
  { sdMode, modeUsedInSd },
  { comMode, modeUsedInProlog|modeUsedInInstance },
  { sdcomMode, modeUsedInSd },
  { piMode, modeUsedInProlog|modeUsedInInstance },
  { refMode, modeUsedInProlog|modeUsedInInstance|modeUsedInSd },
  { imsMode, modeUsedInProlog|modeUsedInInstance },
  { cmsMode, modeUsedInProlog|modeUsedInInstance },
  { rcmsMode, modeUsedInProlog|modeUsedInInstance },
  { proMode, modeUsedInProlog },
  { dsMode, modeUsedInProlog },
  { dsiMode, modeUsedInProlog },
  { plitMode, modeUsedInProlog },
  { plitaMode, modeUsedInProlog },
  { pliteMode, modeUsedInProlog },
  { sdplitMode, modeUsedInSd },
  { sdplitaMode, modeUsedInSd },
  { grpsufMode, modeUsedInProlog },
  { mlitMode, modeUsedInProlog|modeUsedInSd },
  { mlitaMode, modeUsedInProlog|modeUsedInSd },
  { asMode, modeUsedInProlog },
  { slitMode, modeUsedInProlog },
  { slitaMode, modeUsedInProlog },
  { sdslitMode, modeUsedInSd },
  { sdslitaMode, modeUsedInSd },
  { cconMode, modeUsedInInstance },
  { rcconMode, modeUsedInInstance },
  { cconnetMode, modeUsedInInstance },
  { rcconnetMode, modeUsedInInstance },
  { rcconeMode, modeUsedInInstance },
  { tagMode, modeUsedInInstance },
  { econMode, modeUsedInInstance|modeUsesSr },
  { mconMode, modeUsedInInstance|modeUsesSr },
  { econnetMode, modeUsedInInstance|modeUsesSr },
  { mconnetMode, modeUsedInInstance|modeUsesSr },
};

void Parser::compileSdModes()
{
  Mode modes[nModes];
  int n = 0;
  for (size_t i = 0; i < SIZEOF(modeTable); i++)
    if (modeTable[i].flags & modeUsedInSd)
      modes[n++] = modeTable[i].mode;
  compileModes(modes, n, 0);
}

void Parser::compilePrologModes()
{
  Boolean scopeInstance = sd().scopeInstance();
  Boolean haveSr = syntax().hasShortrefs();
  Mode modes[nModes];
  int n = 0;
  for (size_t i = 0; i < SIZEOF(modeTable); i++) {
    if (scopeInstance) {
      if (modeTable[i].flags & modeUsedInProlog)
	modes[n++] = modeTable[i].mode;
    }
    else if (haveSr) {
      if ((modeTable[i].flags & (modeUsedInInstance|modeUsedInProlog))
	  && !(modeTable[i].flags & modeUsesSr))
	modes[n++] = modeTable[i].mode;
    }
    else {
      if (modeTable[i].flags & (modeUsedInInstance|modeUsedInProlog))
	modes[n++] = modeTable[i].mode;
    }
  }
  compileModes(modes, n, 0);
}

void Parser::compileInstanceModes()
{
  Boolean scopeInstance = sd().scopeInstance();
  compileNormalMap();
  if (!scopeInstance && !syntax().hasShortrefs())
    return;
  Mode modes[nModes];
  int n = 0;
  for (size_t i = 0; i < SIZEOF(modeTable); i++) {
    if (scopeInstance) {
      if (modeTable[i].flags & modeUsedInInstance)
	modes[n++] = modeTable[i].mode;
    }
    else {
      if (modeTable[i].flags & modeUsesSr)
	modes[n++] = modeTable[i].mode;
    }
  }
  compileModes(modes, n, &currentDtd());
}

void Parser::compileModes(const Mode *modes,
			  int n,
			  const Dtd *dtd)
{
  PackedBoolean sets[Syntax::nSet];
  PackedBoolean delims[Syntax::nDelimGeneral];
  PackedBoolean functions[3];
  int i;
  Boolean includesShortref = 0;
  for (i = 0; i < Syntax::nSet; i++)
    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++) {
    ModeInfo iter(modes[i], sd());
    TokenInfo ti;
    while (iter.nextToken(&ti)) {
      switch (ti.type) {
      case TokenInfo::delimType:
	delims[ti.delim1] = 1;
	break;
      case TokenInfo::delimDelimType:
	delims[ti.delim1] = 1;
	delims[ti.delim2] = 1;
	break;
      case TokenInfo::delimSetType:
	delims[ti.delim1] = 1;
	// fall through
      case TokenInfo::setType:
	sets[ti.set] = 1;
	break;
      case TokenInfo::functionType:
	functions[ti.function] = 1;
	break;
      }
    }
    if (!includesShortref && iter.includesShortref())
      includesShortref = 1;
  }

  ISet<Char> chars;

  for (i = 0; i < 3; i++)
    if (functions[i])
      chars.add(syntax().standardFunction(i));
  for (i = 0; i < Syntax::nDelimGeneral; i++)
    if (delims[i]) {
      const StringC &str = syntax().delimGeneral(i);
      for (size_t j = 0; j < str.size(); j++)
	chars.add(str[j]);
    }
  if (includesShortref && dtd) {
    size_t n = dtd->nShortref();
    for (size_t i = 0; i < n; i++) {
      const StringC &delim = dtd->shortref(i);
      size_t len = delim.size();
      for (size_t j = 0; j < len; j++)
	if (delim[j] == sd().execToInternal('B'))
	  sets[Syntax::blank] = 1;
	else
	  chars.add(delim[j]);
    }
  }

  const ISet<Char> *csets[Syntax::nSet];
  int usedSets = 0;
  for (i = 0; i < Syntax::nSet; i++)
    if (sets[i])
      csets[usedSets++] = syntax().charSet(i);

  Partition partition(chars, csets, usedSets, *syntax().generalSubstTable());

  String<EquivCode> setCodes[Syntax::nSet];
  
  int nCodes = 0;
  for (i = 0; i < Syntax::nSet; i++)
    if (sets[i])
      setCodes[i] = partition.setCodes(nCodes++);

  String<EquivCode> delimCodes[Syntax::nDelimGeneral];
  for (i = 0; i < Syntax::nDelimGeneral; i++)
    if (delims[i]) {
      StringC str = syntax().delimGeneral(i);
      for (size_t j = 0; j < str.size(); j++)
	delimCodes[i] += partition.charCode(str[j]);
    }

  String<EquivCode> functionCode[3];
  for (i = 0; i < 3; i++)
    if (functions[i])
      functionCode[i] += partition.charCode(syntax().standardFunction(i));

  Vector<SrInfo> srInfo;
      
  int nShortref;
  if (!includesShortref || !dtd)
    nShortref = 0;
  else {
    nShortref = dtd->nShortref();
    srInfo.resize(nShortref);

    for (i = 0; i < nShortref; i++) {
      const StringC delim = dtd->shortref(i);
      SrInfo *p = &srInfo[i];
      size_t j;
      for (j = 0; j < delim.size(); j++) {
	if (delim[j] == sd().execToInternal('B'))
	  break;
	p->chars += partition.charCode(delim[j]);
      }
      if (j < delim.size()) {
	p->bSequenceLength = 1;
	for (++j; j < delim.size(); j++) {
	  if (delim[j] != sd().execToInternal('B'))
	    break;
	  p->bSequenceLength += 1;
	}
	for (; j < delim.size(); j++)
	  p->chars2 += partition.charCode(delim[j]);
      }
      else
	p->bSequenceLength = 0;
    }
  }

  String<EquivCode> dataDelimCodes;
  if (options().warnDataDelim) {
    ModeInfo iter(mconMode, sd());
    TokenInfo ti;
    while (iter.nextToken(&ti)) {
      switch (ti.type) {
      case TokenInfo::delimType:
      case TokenInfo::delimDelimType:
      case TokenInfo::delimSetType:
	{
	  if (ti.token == tokenMscMdc)
	    break;
	  const StringC &delim = syntax().delimGeneral(ti.delim1);
	  if (!delim.size())
	    break;
	  EquivCode c = partition.charCode(delim[0]);
	  for (size_t i = 0; ; i++) {
	    if (i >= dataDelimCodes.size()) {
	      dataDelimCodes += c;
	      break;
	    }
	    if (dataDelimCodes[i] == c)
	      break;
	  }
	}
	break;
      default:
	break;
      }
    }