xmlparser.cc

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

/*
 Copyright (C) 2000-2004

 Code contributed by Greg Collecutt, Joseph Hope and Paul Cochrane

 This file is part of xmds.
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

/*
  $Id: xmlparser.cc,v 1.11 2004/07/27 07:33:54 paultcochrane Exp $
*/

/*! @file xmlparser.cc
  @brief XML parser classes and methods

  More detailed explanation...
*/

#include<xmlbasics.h>
#include<dom3.h>
#include<kissdom.h>
#include<xmlparser.h>

#define DEBUGXMLPARSER 0        //!< Whether or not to debug the XML parser
#define DEBUGXMLENTITYSTREAMS 0 //!< Whether or not to debug the entity streams

// ******************************************************************************
// ******************************************************************************
//	XMLParserException
// ******************************************************************************
// ******************************************************************************

long nXMLParserExceptions=0;  //!< The number of XML parser exceptions

// ******************************************************************************
XMLParserException::XMLParserException() :
  theError(UNKNOWN_ERR),
  theXMLEntityStreamStack(0),
  theErrorMessage("") {
  if(DEBUGXMLPARSER) {
    nXMLParserExceptions++;
    printf("XMLParserException::XMLParserException\n");
    printf("nXMLParserExceptions=%li\n",nXMLParserExceptions);
  }

};

// ******************************************************************************
XMLParserException::XMLParserException(
				       const list<XMLEntityStream*> *const yourXMLEntityStreamStack,
				       const char *const yourErrorMessage,
				       const unsigned short& yourError) :
  theError(yourError),
  theXMLEntityStreamStack(yourXMLEntityStreamStack),
  theErrorMessage(yourErrorMessage) {
  if(DEBUGXMLPARSER) {
    nXMLParserExceptions++;
    printf("XMLParserException::XMLParserException\n");
    printf("nXMLParserExceptions=%li\n",nXMLParserExceptions);
  }

};

// ******************************************************************************
XMLParserException::~XMLParserException() {
  if(DEBUGXMLPARSER) {
    nXMLParserExceptions--;
    printf("XMLParserException::~XMLParserException\n");
    printf("nXMLParserExceptions=%li\n",nXMLParserExceptions);
  }

};

// ******************************************************************************
const char* XMLParserException::getError() {
  const char* errorName;
  switch(theError) {
  case BAD_XML_ERR:
    errorName="XMLParserException::BAD_XML_ERR\n";
    break;
  case ENCODING_NOT_SUPPORTED_ERR:
    errorName="XMLParserException::ENCODING_NOT_SUPPORTED_ERR\n";
    break;
  case INVALID_FILE_ERR :
    errorName="XMLParserException::INVALID_FILE_ERR\n";
    break;
  case INTERNAL_ERR:
    errorName="XMLParserException::INTERNAL_ERR\n";
    break;
  default :
    errorName="XMLParserException::UNKNOWN_ERR\n";
  }

  if(theXMLEntityStreamStack != 0) {
    s[0]=0;
    if(theXMLEntityStreamStack->size()==0) {
      return errorName;
    }
    char s2[256];
    list<XMLEntityStream*>::const_iterator ppXMLEntityStream = theXMLEntityStreamStack->begin();
    sprintf(s2,"%sIn stream '%s', line %li, column %li,",errorName,
	    (*ppXMLEntityStream)->name()->c_str(),
	    (*ppXMLEntityStream)->streamPos.lineNumber,
	    (*ppXMLEntityStream)->streamPos.columnNumber);
    strcat(s,s2);
    ppXMLEntityStream++;
    while(ppXMLEntityStream!=theXMLEntityStreamStack->end()) {
      sprintf(s2,"\n which was referenced from stream '%s', line %li, column %li,",
	      (*ppXMLEntityStream)->name()->c_str(),
	      (*ppXMLEntityStream)->streamPos.lineNumber,
	      (*ppXMLEntityStream)->streamPos.columnNumber);
      strcat(s,s2);
      ppXMLEntityStream++;
    }
    sprintf(s2,"\nthe following error occurred:\n	%s\n",theErrorMessage);
    strcat(s,s2);
    return s;
  }
  else
    return errorName;
};

// ******************************************************************************
// ******************************************************************************
//	XMLEntityStream
// ******************************************************************************
// ******************************************************************************

long nXMLEntityStreams=0;  //!< The number of XML entity streams

// ******************************************************************************
XMLEntityStream::XMLEntityStream(
				 XMLParser *const yourXMLParser,
				 XMLEntityStream *const yourParentXMLEntityStream,
				 const XMLString& yourName,
				 const XMLString& yourSystemID):
  myXMLParser(yourXMLParser),
  myName(yourName),
  myParentXMLEntityStream(yourParentXMLEntityStream),
  mySystemID(yourSystemID) {
	
  if(DEBUGXMLENTITYSTREAMS) {
    nXMLEntityStreams++;
    printf("%s,XMLEntityStream::XMLEntityStream\n",myName.c_str());
    printf("	nXMLEntityStreams=%li\n",nXMLEntityStreams);
  }

  streamPos.count=0;
  streamPos.lineNumber=1;
  streamPos.columnNumber=1;
  errormessage[0]=0;
  myTextStringValid=0;
};

// ******************************************************************************
XMLEntityStream::~XMLEntityStream() {
  if(DEBUGXMLENTITYSTREAMS) {
    nXMLEntityStreams--;
    printf("%s,XMLEntityStream::~XMLEntityStream\n",myName.c_str());
    printf("	nXMLEntityStreams=%li\n",nXMLEntityStreams);
  }

  list<XMLEntityStream*>::iterator ppXMLEntityStream = myXMLEntityStreamList.begin();
  while(ppXMLEntityStream != myXMLEntityStreamList.end()) {
    delete *ppXMLEntityStream;
    ppXMLEntityStream++;
  }
};

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

  return &myName;
};

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

  return myParentXMLEntityStream;
};

// ******************************************************************************
bool XMLEntityStream::atEnd() const {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,XMLEntityStream::atEnd\n",myName.c_str());
  }
	
  return streamPos.count >= myTextString.length();
};

// ******************************************************************************
//char XMLEntityStream::nextChar() {
signed char XMLEntityStream::nextChar() {

  if(!myTextStringValid) {
    makeTextString();
  }

  if(streamPos.count>=myTextString.length()) {
    return EOF;
  }
  else {
    char c=myTextString.data(streamPos.count);
    streamPos.columnNumber++;
    if(c==0x0A) {
      streamPos.lineNumber++;
      streamPos.columnNumber=1;
    }
    streamPos.count++;
    if(DEBUGXMLENTITYSTREAMS) {
      printf("%s:%li,%c\n",myName.c_str(),streamPos.count,c);
    }
    return c;
  }
};

// ******************************************************************************
XMLEntityStream* XMLEntityStream::addParameterXMLEntityStream(
							      const XMLString& name,
							      const XMLString& PublicID,
							      const XMLString& SystemID) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,XMLEntityStream::addParameterXMLEntityStream\n",myName.c_str());
  }

  XMLEntityStream* newXMLEntityStream = new ParameterXMLEntityStream(myXMLParser,this,name,PublicID,SystemID);

  myXMLEntityStreamList.push_front(newXMLEntityStream);

  return newXMLEntityStream;
};

// ******************************************************************************
XMLEntityStream* XMLEntityStream::addParameterXMLEntityStream(
							      const XMLString& name,
							      const XMLString& EntityLiteral) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,XMLEntityStream::addParameterXMLEntityStream\n",myName.c_str());
  }

  XMLEntityStream* newXMLEntityStream = new ParameterXMLEntityStream(myXMLParser,this,name,EntityLiteral);

  myXMLEntityStreamList.push_front(newXMLEntityStream);

  return newXMLEntityStream;
};

// ******************************************************************************
XMLEntityStream* XMLEntityStream::addGeneralXMLEntityStream(
							    const XMLString& name,
							    const XMLString& PublicID,
							    const XMLString& SystemID) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,XMLEntityStream::addGeneralXMLEntityStream\n",myName.c_str());
  }

  XMLEntityStream* newXMLEntityStream = new GeneralXMLEntityStream(myXMLParser,this,name,PublicID,SystemID);

  myXMLEntityStreamList.push_front(newXMLEntityStream);

  return newXMLEntityStream;
};

// ******************************************************************************
XMLEntityStream* XMLEntityStream::addGeneralXMLEntityStream(
							    const XMLString& name,
							    const XMLString& EntityLieteral) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,XMLEntityStrea m::addGeneralXMLEntityStream\n",myName.c_str());
  }

  XMLEntityStream* newXMLEntityStream = new GeneralXMLEntityStream(myXMLParser,this,name,EntityLieteral);

  myXMLEntityStreamList.push_front(newXMLEntityStream);

  return newXMLEntityStream;
};

// ******************************************************************************
XMLEntityStream* XMLEntityStream::addUnparsedXMLEntityStream(
							     const XMLString& name,
							     const XMLString& PublicID,
							     const XMLString& SystemID,
							     const XMLString& NotationName) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,XMLEntityStream::addUnparsedXMLEntityStream\n",myName.c_str());
  }

  XMLEntityStream* newXMLEntityStream =
    new UnparsedXMLEntityStream(myXMLParser,this,name,PublicID,SystemID,NotationName);

  myXMLEntityStreamList.push_front(newXMLEntityStream);

  return newXMLEntityStream;
};

// ******************************************************************************
XMLEntityStream* XMLEntityStream::getXMLEntityStream(
						     const XMLString& getName,
						     const XMLEntityStreamType& ofEntityType) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,XMLEntityStream::getXMLEntityStream\n",myName.c_str());
  }

  XMLEntityStream* testXMLEntityStream;
  XMLEntityStream* nextXMLEntityStream;
  list<XMLEntityStream*>::const_iterator ppXMLEntityStream;

  // first try locally
  testXMLEntityStream=0;
  ppXMLEntityStream = myXMLEntityStreamList.begin();
  while((testXMLEntityStream==0)&(ppXMLEntityStream != myXMLEntityStreamList.end())) {
    if ((*(*ppXMLEntityStream)->name()==getName)&( (*ppXMLEntityStream)->entityType()==ofEntityType)) {
      testXMLEntityStream = *ppXMLEntityStream;
    }
    ppXMLEntityStream++;
  }

  if(testXMLEntityStream==0) {
    // now try the more general search tree downwards routine starting with
    // the immediate parent and working our way up the ancestral line each time
    // it fails, until it gets to Adam.
    if(myParentXMLEntityStream==0) {
      // I am the root element. Go straight to getXMLEntityStreamTreeWalkDown
      testXMLEntityStream = getXMLEntityStreamTreeWalkDown(getName,ofEntityType);
    }
    else {
      nextXMLEntityStream=myParentXMLEntityStream;
      while((testXMLEntityStream==0)&(nextXMLEntityStream!=0)) {
	testXMLEntityStream = nextXMLEntityStream->getXMLEntityStreamTreeWalkDown(getName,ofEntityType);
	nextXMLEntityStream = nextXMLEntityStream->parentXMLEntityStream();
      }
    }
  }
	
  if(testXMLEntityStream!=0) {
    for(list<XMLEntityStream*>::const_iterator ppXMLEntityStream =
	  myXMLParser->XMLEntityStreamStack.begin() ;
	ppXMLEntityStream != myXMLParser->XMLEntityStreamStack.end();
	ppXMLEntityStream++) {
      if(testXMLEntityStream==*ppXMLEntityStream) {
	sprintf(errormessage,"Circular reference to parameter entity '%s'",getName.c_str());
	throw XMLParserException(&myXMLParser->XMLEntityStreamStack,errormessage,
				 XMLParserException::BAD_XML_ERR);
      }
    }
    testXMLEntityStream->streamPos.count=0;
    testXMLEntityStream->streamPos.columnNumber=1;
    testXMLEntityStream->streamPos.lineNumber=1;
  }

  return testXMLEntityStream;
};

// ******************************************************************************
void XMLEntityStream::printStreamTree(
				      unsigned long level) const {

  for(unsigned long i=0;i<level;i++) {
      printf("	");
  }
  printf("%s\n",myName.c_str());

  list<XMLEntityStream*>::const_iterator ppXMLEntityStream = myXMLEntityStreamList.begin();

  while(ppXMLEntityStream != myXMLEntityStreamList.end()) {
    (*ppXMLEntityStream)->printStreamTree(level+1);
    ppXMLEntityStream++;
  }
};

// ******************************************************************************
XMLEntityStream* XMLEntityStream::getXMLEntityStreamTreeWalkDown(
								 const XMLString& name,
								 const XMLEntityStreamType& ofEntityType) {
  if(DEBUGXMLENTITYSTREAMS) {
    printf("%s,XMLEntityStream::getXMLEntityStreamTreeWalkDown\n",myName.c_str());
  }

  if((myName==name)&(entityType()==ofEntityType)) {
    return this;
  }

  XMLEntityStream* testXMLEntityStream=0;
  list<XMLEntityStream*>::const_iterator ppXMLEntityStream = myXMLEntityStreamList.begin();