parsecommon.cxx

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

      else {
	message(ParserMessages::characterNumber, StringMessageArg(currentToken()));
	valid = 0;
	break;
      }
    }
  }
  if (valid && !sd().docCharsetDecl().charDeclared(c)) {
    valid = 0;
    message(ParserMessages::characterNumber, StringMessageArg(currentToken()));
  }
  Owner<Markup> markupPtr;
  if (wantMarkup()) {
    markupPtr = new Markup;
    markupPtr->addDelim(isHex ? Syntax::dHCRO : Syntax::dCRO);
    markupPtr->addNumber(in);
    switch (getToken(refMode)) {
    case tokenRefc:
      markupPtr->addDelim(Syntax::dREFC);
      break;
    case tokenRe:
      markupPtr->addRefEndRe();
      if (options().warnRefc)
	message(ParserMessages::refc);
      break;
    default:
      if (options().warnRefc)
	message(ParserMessages::refc);
      break;
    }
  }
  else if (options().warnRefc) {
    if (getToken(refMode) != tokenRefc)
      message(ParserMessages::refc);
  }
  else
    (void)getToken(refMode);
  if (valid) {
    ch = c;
    loc = Location(new NumericCharRefOrigin(startLocation,
					    currentLocation().index()
					    + currentInput()->currentTokenLength()
					    - startLocation.index(),
					    markupPtr),
		   0);
  }
  return valid;
}

// Translate a character number in the document character set
// into the internal character set.
// If it's a non-SGML char (ie described as UNUSED in SGML declaration),
// return 1 and set sgmlChar to 0.

Boolean Parser::translateNumericCharRef(Char &ch, Boolean &isSgmlChar)
{
  if (sd().internalCharsetIsDocCharset()) {
    if (options().warnNonSgmlCharRef && !syntax().isSgmlChar(ch))
      message(ParserMessages::nonSgmlCharRef);
    isSgmlChar = 1;
    return 1;
  }
  UnivChar univChar;
  if (!sd().docCharset().descToUniv(ch, univChar)) {
    const PublicId *pubid;
    CharsetDeclRange::Type type;
    Number n;
    StringC desc;
    if (sd().docCharsetDecl().getCharInfo(ch, pubid, type, n, desc)) {
      if (type == CharsetDeclRange::unused) {
	if (options().warnNonSgmlCharRef)
	  message(ParserMessages::nonSgmlCharRef);
	isSgmlChar = 0;
	return 1;
      }
    }
    else
      CANNOT_HAPPEN();
    if (type == CharsetDeclRange::string)
      message(ParserMessages::numericCharRefUnknownDesc,
	      NumberMessageArg(ch),
	      StringMessageArg(desc));
    else
      message(ParserMessages::numericCharRefUnknownBase,
	      NumberMessageArg(ch),
	      NumberMessageArg(n),
	      StringMessageArg(pubid->string()));
  }
  else {
    WideChar resultChar;
    ISet<WideChar> resultChars;
    switch (sd().internalCharset().univToDesc(univChar,
					      resultChar,
					      resultChars)) {
    case 1:
      if (resultChar <= charMax) {
	isSgmlChar = 1;
	ch = Char(resultChar);
	return 1;
      }
      // fall through
    case 2:
      message(ParserMessages::numericCharRefBadInternal,
	      NumberMessageArg(ch));
      break;
    default:
      message(ParserMessages::numericCharRefNoInternal,
	      NumberMessageArg(ch));
      break;
    }
  }
  return 0;
}

// ignoreLevel: 0 means don't ignore;
// 1 means parse name group and ignore if inactive
// 2 means ignore

Boolean Parser::parseEntityReference(Boolean isParameter,
				     int ignoreLevel,
				     ConstPtr<Entity> &entity,
				     Ptr<EntityOrigin> &origin)
{
  InputSource *in = currentInput();
  Location startLocation(in->currentLocation());
  Owner<Markup> markupPtr;
  if (wantMarkup()) {
    markupPtr = new Markup;
    markupPtr->addDelim(isParameter ? Syntax::dPERO : Syntax::dERO);
  }
  if (ignoreLevel == 1) {
    Markup savedMarkup;
    Markup *savedCurrentMarkup = currentMarkup();
    if (savedCurrentMarkup)
      savedCurrentMarkup->swap(savedMarkup);
    Location savedMarkupLocation(markupLocation());
    startMarkup(markupPtr != 0, startLocation);
    if (markupPtr) {
      markupPtr->addDelim(Syntax::dGRPO);
      markupPtr->swap(*currentMarkup());
    }
    Boolean ignore;
    if (!parseEntityReferenceNameGroup(ignore))
      return 0;
    if (markupPtr)
      currentMarkup()->swap(*markupPtr);
    startMarkup(savedCurrentMarkup != 0, savedMarkupLocation);
    if (savedCurrentMarkup)
      savedMarkup.swap(*currentMarkup());
    if (!ignore)
      ignoreLevel = 0;
    in->startToken();
    Xchar c = in->tokenChar(messenger());
    if (!syntax().isNameStartCharacter(c)) {
      message(ParserMessages::entityReferenceMissingName);
      return 0;
    }
  }
  in->discardInitial();
  if (isParameter)
    extendNameToken(syntax().penamelen(), ParserMessages::parameterEntityNameLength);
  else
    extendNameToken(syntax().namelen(), ParserMessages::nameLength);
  StringC &name = nameBuffer();
  getCurrentToken(syntax().entitySubstTable(), name);
  if (ignoreLevel)
    entity = new IgnoredEntity(name,
			       isParameter
			       ? Entity::parameterEntity
			       : Entity::generalEntity);
  else {
    entity = lookupEntity(isParameter, name, startLocation, 1);
    if (entity.isNull()) {
      if (haveApplicableDtd()) {
	if (!isParameter) {
	  entity = createUndefinedEntity(name, startLocation);
	  message(ParserMessages::entityUndefined,
		  StringMessageArg(name));
	}
	else 
	  message(ParserMessages::parameterEntityUndefined,
		  StringMessageArg(name));
      }
      else
	message(ParserMessages::entityApplicableDtd);
    }
    else if (entity->defaulted() && options().warnDefaultEntityReference)
      message(ParserMessages::defaultEntityReference, StringMessageArg(name));
  }
  if (markupPtr) {
    markupPtr->addName(in);
    switch (getToken(refMode)) {
    case tokenRefc:
      markupPtr->addDelim(Syntax::dREFC);
      break;
    case tokenRe:
      markupPtr->addRefEndRe();
      if (options().warnRefc)
	message(ParserMessages::refc);
      break;
    default:
      if (options().warnRefc)
	message(ParserMessages::refc);
      break;
    }
  }
  else if (options().warnRefc) {
    if (getToken(refMode) != tokenRefc)
      message(ParserMessages::refc);
  }
  else
    (void)getToken(refMode);
  if (!entity.isNull())
    origin = EntityOrigin::make(internalAllocator(),
				entity,
				startLocation,
				currentLocation().index()
				+ currentInput()->currentTokenLength()
				- startLocation.index(),
				markupPtr);
  else
    origin = (EntityOrigin *)0;
  return 1;
}

Boolean Parser::parseComment(Mode mode)
{
  Location startLoc(currentLocation());
  Markup *markup = currentMarkup();
  if (markup)
    markup->addCommentStart();
  Token token;
  while ((token = getToken(mode)) != tokenCom)
    switch (token) {
    case tokenUnrecognized:
      if (!reportNonSgmlCharacter())
	message(ParserMessages::sdCommentSignificant,
		StringMessageArg(currentToken()));
      break;
    case tokenEe:
      message(ParserMessages::commentEntityEnd, startLoc);
      return 0;
    default:
      if (markup)
	markup->addCommentChar(currentChar());
      break;
    }
  return 1;
}

void Parser::extendNameToken(size_t maxLength,
			     const MessageType1 &tooLongMessage)
{
  InputSource *in = currentInput();
  size_t length = in->currentTokenLength();
  const Syntax &syn = syntax();
  while (syn.isNameCharacter(in->tokenChar(messenger())))
    length++;
  if (length > maxLength)
    message(tooLongMessage, NumberMessageArg(maxLength));
  in->endToken(length);
}

void Parser::extendNumber(size_t maxLength, const MessageType1 &tooLongMessage)
{
  InputSource *in = currentInput();
  size_t length = in->currentTokenLength();
  while (syntax().isDigit(in->tokenChar(messenger())))
    length++;
  if (length > maxLength)
    message(tooLongMessage, NumberMessageArg(maxLength));
  in->endToken(length);
}

void Parser::extendHexNumber()
{
  InputSource *in = currentInput();
  size_t length = in->currentTokenLength();
  while (syntax().isHexDigit(in->tokenChar(messenger())))
    length++;
  if (length > syntax().namelen())
    message(ParserMessages::hexNumberLength, NumberMessageArg(syntax().namelen()));
  in->endToken(length);
}

Boolean Parser::reportNonSgmlCharacter()
{
  // In scanSuppress mode the non-SGML character will have been read.
  Char c = currentInput()->currentTokenLength() ? currentChar() : getChar();
  if (!syntax().isSgmlChar(c)) {
    message(ParserMessages::nonSgmlCharacter, NumberMessageArg(c));
    return 1;
  }
  return 0;
}

void Parser::extendS()
{
  InputSource *in = currentInput();
  size_t length = in->currentTokenLength();
  while (syntax().isS(in->tokenChar(messenger())))
    length++;
  in->endToken(length);
}

#ifdef SP_NAMESPACE
}
#endif