parsesd.cxx

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

}

Boolean Parser::sdParseSyntaxCharset(SdBuilder &sdBuilder, SdParam &parm)
{
  UnivCharsetDesc desc;
  if (!sdParseCharset(sdBuilder, parm, 0, sdBuilder.syntaxCharsetDecl, desc))
    return 0;
  sdBuilder.syntaxCharset.set(desc);
  checkSwitches(sdBuilder.switcher, sdBuilder.syntaxCharset);
  for (size_t i = 0; i < sdBuilder.switcher.nSwitches(); i++)
    if (!sdBuilder.syntaxCharsetDecl.charDeclared(sdBuilder.switcher.switchTo(i)))
      message(ParserMessages::switchNotInCharset,
	      NumberMessageArg(sdBuilder.switcher.switchTo(i)));
  ISet<WideChar> missing;
  findMissingMinimum(sdBuilder.syntaxCharset, missing);
  if (!missing.isEmpty())
    message(ParserMessages::missingMinimumChars,
	    CharsetMessageArg(missing));
  return 1;
}

Boolean Parser::sdParseShunchar(SdBuilder &sdBuilder, SdParam &parm)
{
  if (!parseSdParam(AllowedSdParams(SdParam::reservedName + Sd::rNONE,
				    SdParam::reservedName + Sd::rCONTROLS,
				    SdParam::number), parm))
    return 0;
  if (parm.type == SdParam::reservedName + Sd::rNONE) {
    if (!parseSdParam(AllowedSdParams(SdParam::reservedName + Sd::rBASESET),
		      parm))
      return 0;
    return 1;
  }
  if (parm.type == SdParam::reservedName + Sd::rCONTROLS)
    sdBuilder.syntax->setShuncharControls();
  else {
    if (parm.n <= charMax)
      sdBuilder.syntax->addShunchar(Char(parm.n));
  }
  for (;;) {
    if (!parseSdParam(AllowedSdParams(SdParam::reservedName + Sd::rBASESET,
				      SdParam::number), parm))
      return 0;
    if (parm.type != SdParam::number)
      break;
    if (parm.n <= charMax)
      sdBuilder.syntax->addShunchar(Char(parm.n));
  }
  return 1;
}

Boolean Parser::sdParseFunction(SdBuilder &sdBuilder, SdParam &parm)
{
  static Sd::ReservedName standardNames[3] = {
    Sd::rRE, Sd::rRS, Sd::rSPACE
  };
  for (int i = 0; i < 3; i++) {
    if (!parseSdParam(AllowedSdParams(SdParam::reservedName
				      + standardNames[i]),
		      parm))
      return 0;
    if (!parseSdParam(AllowedSdParams(SdParam::number), parm))
      return 0;
    Char c;
    if (translateSyntax(sdBuilder, parm.n, c)) {
      if (checkNotFunction(*sdBuilder.syntax, c))
	sdBuilder.syntax->setStandardFunction(Syntax::StandardFunction(i), c);
      else
	sdBuilder.valid = 0;
    }
  }
  Boolean haveMsichar = 0;
  Boolean haveMsochar = 0;
  for (;;) {
    if (!parseSdParam(sdBuilder.externalSyntax
		      ? AllowedSdParams(SdParam::name, SdParam::paramLiteral)
		      : AllowedSdParams(SdParam::name),
		      parm))
      return 0;
    Boolean nameWasLiteral;
    size_t nameMarkupIndex;
    if (currentMarkup())
      nameMarkupIndex = currentMarkup()->size() - 1;
    Boolean invalidName = 0;
    StringC name;
    if (parm.type == SdParam::paramLiteral) {
      nameWasLiteral = 1;
      if (!translateSyntax(sdBuilder, parm.paramLiteralText, name))
	invalidName = 1;
    }
    else {
      parm.token.swap(name);
      nameWasLiteral = 0;
    }
    if (!parseSdParam(nameWasLiteral
		      ? AllowedSdParams(SdParam::reservedName + Sd::rFUNCHAR,
					SdParam::reservedName + Sd::rMSICHAR,
					SdParam::reservedName + Sd::rMSOCHAR,
					SdParam::reservedName + Sd::rMSSCHAR,
					SdParam::reservedName + Sd::rSEPCHAR)
		      : AllowedSdParams(SdParam::reservedName + Sd::rFUNCHAR,
					SdParam::reservedName + Sd::rMSICHAR,
					SdParam::reservedName + Sd::rMSOCHAR,
					SdParam::reservedName + Sd::rMSSCHAR,
					SdParam::reservedName + Sd::rSEPCHAR,
					SdParam::reservedName + Sd::rLCNMSTRT),
		      parm))
      return 0;
    if (parm.type == SdParam::reservedName + Sd::rLCNMSTRT) {
      if (name != sd().reservedName(Sd::rNAMING))
	message(ParserMessages::namingBeforeLcnmstrt,
		StringMessageArg(name));
      else if (currentMarkup())
	currentMarkup()->changeToSdReservedName(nameMarkupIndex, Sd::rNAMING);
      break;
    }
    if (!nameWasLiteral) {
      StringC tem;
      name.swap(tem);
      if (!translateName(sdBuilder, tem, name))
	invalidName = 1;
    }
    Syntax::FunctionClass functionClass;
    switch (parm.type) {
    case SdParam::reservedName + Sd::rFUNCHAR:
      functionClass = Syntax::cFUNCHAR;
      break;
    case SdParam::reservedName + Sd::rMSICHAR:
      haveMsichar = 1;
      functionClass = Syntax::cMSICHAR;
      break;
    case SdParam::reservedName + Sd::rMSOCHAR:
      haveMsochar = 1;
      functionClass = Syntax::cMSOCHAR;
      break;
    case SdParam::reservedName + Sd::rMSSCHAR:
      functionClass = Syntax::cMSSCHAR;
      break;
    case SdParam::reservedName + Sd::rSEPCHAR:
      functionClass = Syntax::cSEPCHAR;
      break;
    default:
      CANNOT_HAPPEN();
    }
    if (!parseSdParam(AllowedSdParams(SdParam::number), parm))
      return 0;
    Char c;
    if (translateSyntax(sdBuilder, parm.n, c)
        && checkNotFunction(*sdBuilder.syntax, c)
	&& !invalidName) {
      Char tem;
      if (sdBuilder.syntax->lookupFunctionChar(name, &tem))
	message(ParserMessages::duplicateFunctionName, StringMessageArg(name));
      else
	sdBuilder.syntax->addFunctionChar(name, functionClass, c);
    }
  }
  if (haveMsochar && !haveMsichar)
    message(ParserMessages::msocharRequiresMsichar);
  return 1;
}

Boolean Parser::sdParseNaming(SdBuilder &sdBuilder, SdParam &parm)
{
  static Sd::ReservedName keys[6] = {
    Sd::rUCNMSTRT, Sd::rNAMESTRT, Sd::rLCNMCHAR, Sd::rUCNMCHAR, Sd::rNAMECHAR,
    Sd::rNAMECASE
  };
  int isNamechar = 0;
  ISet<Char> nameStartChar;
  ISet<Char> nameChar;
  do {
    String<SyntaxChar> lc;
    Vector<size_t> rangeIndex;
    enum PrevParam {
      paramNone,
      paramNumber,
      paramOther
    } prevParam = paramNone;
      
    for (;;) {
      switch (prevParam) {
      case paramNone:
	if (!parseSdParam(AllowedSdParams(SdParam::paramLiteral, SdParam::number),
	                  parm))
	  return 0;
	break;
      case paramNumber:
	if (!parseSdParam(AllowedSdParams(SdParam::reservedName
					  + keys[isNamechar * 3],
					  SdParam::paramLiteral,
					  SdParam::number,
					  SdParam::minus),
			  parm))
	  return 0;
	break;
      case paramOther:
	if (!parseSdParam(AllowedSdParams(SdParam::reservedName
					  + keys[isNamechar * 3],
					  SdParam::paramLiteral,
					  SdParam::number),
			  parm))
	  return 0;
	break;
      }
      switch (parm.type) {
      case SdParam::paramLiteral:
	if (prevParam == paramNone)
	  break;
	// fall through
      case SdParam::number:
	if (!sdBuilder.externalSyntax && !sdBuilder.enr) {
	  message(ParserMessages::enrRequired);
	  sdBuilder.enr = 1;
	}
	break;
      default:
	break;
      }
      prevParam = (parm.type == SdParam::number ? paramNumber : paramOther);
      if (parm.type == SdParam::minus) {
	if (!parseSdParam(AllowedSdParams(SdParam::number),
			  parm))
	  return 0;
	if (parm.n < lc[lc.size() - 1])
	  message(ParserMessages::sdInvalidRange);
	else {
	  if (parm.n > lc[lc.size() - 1] + 1)
	    rangeIndex.push_back(lc.size() - 1);
	  lc += SyntaxChar(parm.n);
	}
      }
      else {
	sdParamConvertToLiteral(parm);
	if (parm.type != SdParam::paramLiteral)
	  break;
	lc += parm.paramLiteralText;
      }
    }
    size_t lcPos = 0;
    size_t rangeIndexPos = 0;
    unsigned long rangeLeft = 0;
    SyntaxChar nextRangeChar;
    ISet<Char> &set = isNamechar ? nameChar : nameStartChar;
    String<SyntaxChar> chars;
    Boolean runOut = 0;
    prevParam = paramNone;
    for (;;) {
      switch (prevParam) {
      case paramNone:
	if (!parseSdParam(AllowedSdParams(SdParam::paramLiteral, SdParam::number),
	                  parm))
	  return 0;
	break;
      case paramNumber:
	if (!parseSdParam(AllowedSdParams(SdParam::reservedName
					  + keys[isNamechar * 3 + 1],
					  SdParam::reservedName
					  + keys[isNamechar * 3 + 2],
					  SdParam::paramLiteral,
					  SdParam::number,
					  SdParam::minus),
			  parm))
	  return 0;
	break;
      case paramOther:
	if (!parseSdParam(AllowedSdParams(SdParam::reservedName
					  + keys[isNamechar * 3 + 1],
					  SdParam::reservedName
					  + keys[isNamechar * 3 + 2],
					  SdParam::paramLiteral,
					  SdParam::number),
			  parm))
	  return 0;
	break;
      }
      switch (parm.type) {
      case SdParam::paramLiteral:
	if (prevParam == paramNone)
	  break;
	// fall through
      case SdParam::number:
	if (!sdBuilder.externalSyntax && !sdBuilder.enr) {
	  message(ParserMessages::enrRequired);
	  sdBuilder.enr = 1;
	}
	break;
      default:
	break;
      }
      prevParam = (parm.type == SdParam::number ? paramNumber : paramOther);
      if (parm.type == SdParam::minus) {
	if (!parseSdParam(AllowedSdParams(SdParam::number),
			  parm))
	  return 0;
	ASSERT(chars.size() == 1);
	SyntaxChar start = chars[0];
  	SyntaxChar end = parm.n;
	if (start > end)
	  message(ParserMessages::sdInvalidRange);
	else {
	  size_t count = end + 1 - start;
	  while (count > 0) {
	    if (rangeLeft == 0
		&& rangeIndexPos < rangeIndex.size()
		&& rangeIndex[rangeIndexPos] == lcPos) {
	      rangeLeft = 1 + lc[lcPos + 1] - lc[lcPos];
	      nextRangeChar = lc[lcPos];
	      lcPos += 2;
	      rangeIndexPos += 1;
	    }
	    Char c;
	    if (rangeLeft > 0) {
	      rangeLeft--;
	      c = nextRangeChar++;
	    }
	    else if (lcPos < lc.size())
	      c = lc[lcPos++];
	    else {
	      c = start;
	      runOut = 1;
	    }
	    if (c == start && count > 1 && (runOut || rangeLeft > 0)) {
	      size_t n;
	      if (runOut)
		n = count;
	      else if (rangeLeft < count) {
		// rangeLeft + 1 <= count
		n = rangeLeft + 1;
		rangeLeft = 0;
	      }
	      else {
		// count < rangeLeft + 1
		n = count;
		rangeLeft -= n - 1;
		nextRangeChar += n - 1;
	      }
	      translateRange(sdBuilder, start, start + (n - 1), set);
	      count -= n;
	      start += n;
	    }
	    else {
	      Char transLc, transUc;
	      if (translateSyntax(sdBuilder, c, transLc)
		  && translateSyntax(sdBuilder, start, transUc)) {
		set.add(transLc);
		if (transLc != transUc) {
		  set.add(transUc);
		  sdBuilder.syntax->addSubst(transLc, transUc);
		}
	      }
	      count--;
	      start++;
	    }
	  } 
	}
	chars.resize(0);
      }
      else {
	for (size_t i = 0; i < chars.size(); i++) {
	  if (rangeLeft == 0
	      && rangeIndexPos < rangeIndex.size()
	      && rangeIndex[rangeIndexPos] == lcPos) {
	    rangeLeft = 1 + lc[lcPos + 1] - lc[lcPos];
	    nextRangeChar = lc[lcPos];
	    lcPos += 2;
	    rangeIndexPos += 1;
	  }
	  Char c;
	  if (rangeLeft > 0) {
	    rangeLeft--;
	    c = nextRangeChar++;
	  }
	  else if (lcPos < lc.size())
	    c = lc[lcPos++];
	  else {
	    runOut = 1;
	    c = chars[i];
	  }
	  // map from c to chars[i]
	  Char transLc, transUc;
	  if (translateSyntax(sdBuilder, c, transLc)
	      && translateSyntax(sdBuilder, chars[i], transUc)) {
	    set.add(transLc);
	    if (transLc != transUc) {
	      set.add(transUc);
	      sdBuilder.syntax->addSubst(transLc, transUc);
	    }
	  }
	}
	sdParamConvertToLiteral(parm);
	if (parm.type != SdParam::paramLiteral)
	  break;
	parm.paramLiteralText.swap(chars);
      }
    }
    if ((runOut && !sdBuilder.externalSyntax)
	|| rangeLeft > 0 || lcPos < lc.size())
      message(isNamechar
	      ? ParserMessages::nmcharLength
	      : ParserMessages::nmstrtLength);
    if (parm.type == SdParam::reservedName + keys[isNamechar * 3 + 1]) {
      if (!sdBuilder.externalSyntax && !sdBuilder.enr) {
	message(ParserMessages::enrRequired);
	sdBuilder.enr = 1;
      }
      prevParam = paramNone;
      for (;;) {
	switch (prevParam) {
	case paramNone:
	  if (!parseSdParam(AllowedSdParams(SdParam::paramLiteral, SdParam::number),
			    parm))
	    return 0;
	  break;
	case paramNumber:
	  if (!parseSdParam(AllowedSdParams(SdParam::reservedName
					    + keys[isNamechar * 3 + 2],
					    SdParam::paramLiteral,
					    SdParam::number,
					    SdParam::minus),
			    parm))
	    return 0;
	  break;
	case paramOther:
	  if (!parseSdParam(AllowedSdParams(SdParam::reservedName
					    + keys[isNamechar * 3 + 2],
					    SdParam::paramLiteral,
					    SdParam::number),
			    parm))
	    return 0;
	  break;
	}
	prevParam = (parm.type == SdParam::number ? paramNumber : paramOther);
	if (parm.type == SdParam::minus) {
	  SyntaxChar prevNumber = parm.n;
	  if (!parseSdParam(AllowedSdParams(SdParam::number),
			    parm))
	    return 0;
	  if (parm.n < prevNumber)
	    message(ParserMessages::sdInvalidRange);
	  else if (parm.n > prevNumber)
	    translateRange(sdBuilder, prevNumber + 1, parm.n, set);
	}
	else {
	  sdParamConvertToLiteral(parm);
	  if (parm.type != SdParam::paramLiteral)
	    break;
	  for (size_t i = 0; i < parm.paramLiteralText.size(); i++) {
	    Char trans;
	    if (translateSyntax(sdBuilder, parm.paramLiteralText[i], trans))
	      set.add(trans);
	  }
	}