xmlparser.cc

XMDS is a code generator that integrates equations. You write them down in human readable form in a

  while((testXMLEntityStream==0)&(ppXMLEntityStream != myXMLEntityStreamList.end())) {
    testXMLEntityStream = (*ppXMLEntityStream)->getXMLEntityStreamTreeWalkDown(name,ofEntityType);
    ppXMLEntityStream++;
  }

  return testXMLEntityStream;
};

// ******************************************************************************
void XMLEntityStream::loadExternalTextString() {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,XMLEntityStream::loadExternalTextString\n",myName.c_str());
  }

  // check that file exists
  FILE *infile = fopen(mySystemID.c_str(),"r");
  if(infile==0) {
    sprintf(errormessage,"Cannot open '%s' for reading",mySystemID.c_str());
    throw XMLParserException(&myXMLParser->XMLEntityStreamStack, errormessage,XMLParserException::INVALID_FILE_ERR);
  }

  // load file into myTextString;
  myTextString.loadFromFile(infile);

  fclose(infile);
};

// ******************************************************************************
// ******************************************************************************
//	RootXMLEntityStream
// ******************************************************************************
// ******************************************************************************

// ******************************************************************************
RootXMLEntityStream::RootXMLEntityStream(
					 XMLParser *const yourXMLParser,
					 const XMLString& yourSystemID):
  XMLEntityStream(yourXMLParser,0,"document_entity",yourSystemID) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,RootXMLEntityStream::RootXMLEntityStream\n",myName.c_str());
  }
};

// ******************************************************************************
XMLEntityStream::XMLEntityStreamType RootXMLEntityStream::entityType() const {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,RootXMLEntityStream::entityType\n",myName.c_str());
  }

  return ROOT_ENTITY;
};

// ******************************************************************************
XMLEntityStream::XMLEntityLocationType RootXMLEntityStream::entityLocation() const {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,RootXMLEntityStream::entityLocation\n",myName.c_str());
  }

  return INTERNAL_ENTITY;
};

// ******************************************************************************
const XMLString* RootXMLEntityStream::replacementText() {
  throw XMLParserException(&myXMLParser->XMLEntityStreamStack, "RootXMLEntityStream::replacementText() called!",
			   XMLParserException::INTERNAL_ERR);
};

// ******************************************************************************
void RootXMLEntityStream::makeTextString() {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,RootXMLEntityStream::makeTextString\n",myName.c_str());
  }

  loadExternalTextString();

  myTextStringValid=1;
};

// ******************************************************************************
// ******************************************************************************
//	GPXMLEntityStream
// ******************************************************************************
// ******************************************************************************

// ******************************************************************************
// constructor for an internal entity
GPXMLEntityStream::GPXMLEntityStream(
				     XMLParser *const yourXMLParser,
				     XMLEntityStream *const yourParentXMLEntityStream,
				     const XMLString& yourName,
				     const XMLString& yourEntityLiteral):
  XMLEntityStream(yourXMLParser,yourParentXMLEntityStream,yourName,""),
  myPublicID(""),
  myEntityLiteral(yourEntityLiteral),
  myEntityLocation(INTERNAL_ENTITY) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,GPXMLEntityStream::GPXMLEntityStream - internal\n",myName.c_str());
  }
};

// ******************************************************************************
// constructor for an external entity
GPXMLEntityStream::GPXMLEntityStream(
				     XMLParser *const yourXMLParser,
				     XMLEntityStream *const yourParentXMLEntityStream,
				     const XMLString& yourName,
				     const XMLString& yourPublicID,
				     const XMLString& yourSystemID):
  XMLEntityStream(yourXMLParser,yourParentXMLEntityStream,yourName,yourSystemID),
  myPublicID(yourPublicID),
  myEntityLiteral(""),
  myEntityLocation(EXTERNAL_ENTITY) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,GPXMLEntityStream::GPXMLEntityStream - external\n",myName.c_str());
  }
};

// ******************************************************************************
XMLEntityStream::XMLEntityLocationType GPXMLEntityStream::entityLocation() const {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,GPXMLEntityStream::entityLocation\n",myName.c_str());
  }

  return myEntityLocation;
};

// ******************************************************************************
const XMLString* GPXMLEntityStream::replacementText() {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,GPXMLEntityStream::replacementText\n",myName.c_str());
  }

  if(!myTextStringValid) {
    makeTextString();
  }

  return &myTextString;
};

// ******************************************************************************
void GPXMLEntityStream::makeTextString() {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,GPXMLEntityStream::makeTextString\n",myName.c_str());
  }

  myTextStringValid=1;

  if(myEntityLocation==EXTERNAL_ENTITY) {
    loadExternalTextString();
    // parse for TextDecl
    XMLString VersionNum;
    XMLString EncName;
    myXMLParser->matchProduction77TextDecl(this,VersionNum,EncName);
    // now remove TextDecl from myTextString
    myTextString.replaceData(0,streamPos.count,"");
    streamPos.count=0;
    return;
  }

  // if here, we must be an internal entity, in which case we ought to
  // be preparsed for character and parameter entity refs

  myTextString=myEntityLiteral;

  //char c;
  signed char c;
  unsigned long refLength;
  XMLString refName;
  XMLEntityStream* refXMLEntityStream;

  StreamPositionStruct lastPos;

  lastPos=streamPos;
  c=nextChar();
  while(c!=EOF) {
    if(c=='&') {
      streamPos=lastPos;
      refLength=myXMLParser->matchProduction66CharRef(this,c);
      streamPos=lastPos;
      if(refLength>0) {
	const char s[2]={c,0};
	myTextString.replaceData(streamPos.count,refLength,s);
	streamPos.columnNumber += refLength;
	streamPos.count++;
      }
      lastPos=streamPos;
      c=nextChar();
    }
    if(c=='%') {
      // might be the % in an <!ENTITY % name ...> declaration
      // therefore check next character, and proceed only if not a WhiteSpace
      c=nextChar();
      if(!XMLChar::isWhiteSpace(c)) {
	streamPos=lastPos;
	refLength=myXMLParser->matchProduction69PEReference(this,refName);
	streamPos=lastPos;
	refXMLEntityStream = getXMLEntityStream(refName,XMLEntityStream::PARAMETER_ENTITY);
	if(refXMLEntityStream==0) {
	  sprintf(errormessage,"Parameter entity '%s' unknown",refName.c_str());
	  throw XMLParserException(&myXMLParser->XMLEntityStreamStack,errormessage,XMLParserException::BAD_XML_ERR);
	}
	myXMLParser->XMLEntityStreamStack.push_front(refXMLEntityStream);
	myTextString.replaceData(streamPos.count,refLength,
				 *refXMLEntityStream->replacementText());
	myXMLParser->XMLEntityStreamStack.pop_front();
      }
    }
    lastPos=streamPos;
    c=nextChar();
  }

  streamPos.count=0;
  streamPos.lineNumber=1;
  streamPos.columnNumber=1;

  if(DEBUGXMLENTITYSTREAMS) {
    printf("myTextString=%s\n",myTextString.c_str());
  }
};


// ******************************************************************************
// ******************************************************************************
//	ParameterXMLEntityStream
// ******************************************************************************
// ******************************************************************************

// ******************************************************************************
// constructor for an internal entity
ParameterXMLEntityStream::ParameterXMLEntityStream(
						   XMLParser *const yourXMLParser,
						   XMLEntityStream *const yourParentXMLEntityStream,
						   const XMLString& yourName,
						   const XMLString& yourEntityLiteral):
  GPXMLEntityStream(yourXMLParser,yourParentXMLEntityStream,yourName,yourEntityLiteral) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,ParameterXMLEntityStream::ParameterXMLEntityStream - internal\n",myName.c_str());
  }
};

// ******************************************************************************
// constructor for an external entity
ParameterXMLEntityStream::ParameterXMLEntityStream(
						   XMLParser *const yourXMLParser,
						   XMLEntityStream *const yourParentXMLEntityStream,
						   const XMLString& yourName,
						   const XMLString& yourPublicID,
						   const XMLString& yourSystemID):
  GPXMLEntityStream(yourXMLParser,yourParentXMLEntityStream,yourName,yourPublicID,yourSystemID) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,ParameterXMLEntityStream::ParameterXMLEntityStream - external\n",myName.c_str());
  }
};

// ******************************************************************************
XMLEntityStream::XMLEntityStreamType ParameterXMLEntityStream::entityType() const {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,ParameterXMLEntityStream::entityType\n",myName.c_str());
  }

  return PARAMETER_ENTITY;
};

// ******************************************************************************
// ******************************************************************************
//	GeneralXMLEntityStream
// ******************************************************************************
// ******************************************************************************

// ******************************************************************************
// constructor for an internal entity
GeneralXMLEntityStream::GeneralXMLEntityStream(
					       XMLParser *const yourXMLParser,
					       XMLEntityStream *const yourParentXMLEntityStream,
					       const XMLString& yourName,
					       const XMLString& yourEntityLiteral):
  GPXMLEntityStream(yourXMLParser,yourParentXMLEntityStream,yourName,yourEntityLiteral) {

  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,GeneralXMLEntityStream::GeneralXMLEntityStream - internal\n",myName.c_str());
  }
};

// ******************************************************************************
// constructor for an external entity
GeneralXMLEntityStream::GeneralXMLEntityStream(
					       XMLParser *const yourXMLParser,
					       XMLEntityStream *const yourParentXMLEntityStream,
					       const XMLString& yourName,
					       const XMLString& yourPublicID,
					       const XMLString& yourSystemID):
  GPXMLEntityStream(yourXMLParser,yourParentXMLEntityStream,yourName,yourPublicID,yourSystemID) {

  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,GeneralXMLEntityStream::GeneralXMLEntityStream - external\n",myName.c_str());
  }
};

// ******************************************************************************
XMLEntityStream::XMLEntityStreamType GeneralXMLEntityStream::entityType() const {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,GeneralXMLEntityStream::entityType\n",myName.c_str());
  }

  return GENERAL_ENTITY;
};

// ******************************************************************************
// ******************************************************************************
//	UnparsedXMLEntityStream
// ******************************************************************************
// ******************************************************************************

// ******************************************************************************
UnparsedXMLEntityStream::UnparsedXMLEntityStream(
						 XMLParser *const yourXMLParser,
						 XMLEntityStream *const yourParentXMLEntityStream,
						 const XMLString& yourName,
						 const XMLString& yourPublicID,
						 const XMLString& yourSystemID,
						 const XMLString& yourNotationName):
  XMLEntityStream(yourXMLParser,yourParentXMLEntityStream,yourName,yourSystemID),
  myPublicID(yourPublicID),
  myNotationName(yourNotationName) {

  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,UnparsedXMLEntityStream::UnparsedXMLEntityStream\n",myName.c_str());
  }
};

// ******************************************************************************
XMLEntityStream::XMLEntityStreamType UnparsedXMLEntityStream::entityType() const {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,UnparsedXMLEntityStream::entityType\n",myName.c_str());
  }

  return UNPARSED_ENTITY;
};

// ******************************************************************************
XMLEntityStream::XMLEntityLocationType UnparsedXMLEntityStream::entityLocation() const {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,UnparsedXMLEntityStream::entityLocation\n",myName.c_str());
  }

  return EXTERNAL_ENTITY;
};

// ******************************************************************************
const XMLString* UnparsedXMLEntityStream::replacementText() {
  throw XMLParserException(&myXMLParser->XMLEntityStreamStack,"UnparsedXMLEntityStream::replacementText() called!",
			   XMLParserException::INTERNAL_ERR);
};

// ******************************************************************************
bool UnparsedXMLEntityStream::atEnd() const {
  return 1;
};

// ******************************************************************************
XMLEntityStream* UnparsedXMLEntityStream::addParameterXMLEntityStream(
								      const XMLString& name,
								      const XMLString& PublicID,
								      const XMLString& SystemID) {
  throw XMLParserException(&myXMLParser->XMLEntityStreamStack,"UnparsedXMLEntityStream::addParameterXMLEntityStream() called!",
			   XMLParserException::INTERNAL_ERR);
};

// ******************************************************************************
XMLEntityStream* UnparsedXMLEntityStream::addParameterXMLEntityStream(
								      const XMLString& name,
								      const XMLString& EntityLiteral) {
  throw XMLParserException(&myXMLParser->XMLEntityStreamStack,"UnparsedXMLEntityStream::addParameterXMLEntityStream() called!",
			   XMLParserException::INTERNAL_ERR);
};

// ******************************************************************************
XMLEntityStream* UnparsedXMLEntityStream::addGeneralXMLEntityStream(
								    const XMLString& name,
								    const XMLString& EntityLiteral) {
  throw XMLParserException(&myXMLParser->XMLEntityStreamStack,"UnparsedXMLEntityStream::addGeneralXMLEntityStream() called!",
			   XMLParserException::INTERNAL_ERR);
};

// ******************************************************************************
XMLEntityStream* UnparsedXMLEntityStream::addGeneralXMLEntityStream(
								    const XMLString& name,
								    const XMLString& PublicID,
								    const XMLString& SystemID,
								    const XMLString& NotationName) {
  throw XMLParserException(&myXMLParser->XMLEntityStreamStack,"UnparsedXMLEntityStream::addGeneralXMLEntityStream() called!",
			   XMLParserException::INTERNAL_ERR);
};

// ******************************************************************************
XMLEntityStream* UnparsedXMLEntityStream::addUnparsedXMLEntityStream(
								     const XMLString& name,
								     const XMLString& PublicID,
								     const XMLString& SystemID,
								     const XMLString& NotationName) {
  throw XMLParserException(&myXMLParser->XMLEntityStreamStack,"UnparsedXMLEntityStream::addUnparsedXMLEntityStream() called!",
			   XMLParserException::INTERNAL_ERR);
};