CCopasiXMLParser.cpp

Go to the documentation of this file.

// Copyright (C) 2010 - 2015 by Pedro Mendes, Virginia Tech Intellectual
// Properties, Inc., University of Heidelberg, and The University
// of Manchester.
// All rights reserved.

// Copyright (C) 2008 - 2009 by Pedro Mendes, Virginia Tech Intellectual
// Properties, Inc., EML Research, gGmbH, University of Heidelberg,
// and The University of Manchester.
// All rights reserved.

// Copyright (C) 2003 - 2007 by Pedro Mendes, Virginia Tech Intellectual
// Properties, Inc. and EML Research, gGmbH.
// All rights reserved.

/**
 * CCopasiXMLParser class.
 * This class parses a COPASI XML file.
 *
 * Created for COPASI by Stefan Hoops 2003
 * Copyright Stefan Hoops
 */

#include "copasi.h"

#include "CExpat.h"

#include "CCopasiXMLParser.h"
#include "CCopasiXMLInterface.h"
#include "utilities/CCopasiMessage.h"
#include "function/CFunction.h"
#include "function/CExpression.h"
#include "model/CModel.h"
#include "model/CModelParameterSet.h"
#include "report/CKeyFactory.h"
#include "report/CReportDefinitionVector.h"
#include "report/CReportDefinition.h"

#include "utilities/CVersion.h"
#include "utilities/CCopasiParameter.h"
#include "utilities/CCopasiParameterGroup.h"
#include "utilities/CSlider.h"
#include "steadystate/CSteadyStateTask.h"
#include "steadystate/CMCATask.h"
#include "lna/CLNATask.h"
#include "tssanalysis/CTSSATask.h"
#include "scan/CScanTask.h"
#include "elementaryFluxModes/CEFMTask.h"
#include "optimization/COptTask.h"
#include "parameterFitting/CFitTask.h"
#include "trajectory/CTrajectoryTask.h"
#include "lyap/CLyapTask.h"
#include "sensitivities/CSensTask.h"
#include "moieties/CMoietiesTask.h"
#include "crosssection/CCrossSectionTask.h"
#include "plot/COutputDefinitionVector.h"
#include "plot/CPlotSpecification.h"
#include "plot/CPlotItem.h"
#include "CopasiDataModel/CCopasiDataModel.h"
#include "layout/CListOfLayouts.h"
#include "report/CCopasiRootContainer.h"

#include "copasi/layout/CLGradientStop.h"
#include "copasi/layout/CLGradientBase.h"
#include "copasi/layout/CLLinearGradient.h"
#include "copasi/layout/CLRadialGradient.h"
#include "copasi/layout/CLColorDefinition.h"
#include "copasi/layout/CLRenderPoint.h"
#include "copasi/layout/CLRenderCubicBezier.h"
#include "copasi/layout/CLTransformation.h"
#include "copasi/layout/CLTransformation2D.h"
#include "copasi/layout/CLImage.h"
#include "copasi/layout/CLText.h"
#include "copasi/layout/CLRenderCurve.h"
#include "copasi/layout/CLPolygon.h"
#include "copasi/layout/CLEllipse.h"
#include "copasi/layout/CLRectangle.h"
#include "copasi/layout/CLLocalStyle.h"
#include "copasi/layout/CLGlobalStyle.h"
#include "copasi/layout/CLRenderInformationBase.h"
#include "copasi/layout/CLLocalRenderInformation.h"
#include "copasi/layout/CLGlobalRenderInformation.h"

#define START_ELEMENT   -1
#define UNKNOWN_ELEMENT -2

#ifdef COPASI_TEMPLATE
CCopasiXMLParser::TEMPLATEElement::TEMPLATEElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::TEMPLATEElement::~TEMPLATEElement()
{
  pdelete(mpetcElement);
}

void CCopasiXMLParser::TEMPLATEElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mpCurrentHandler = NULL;
  mCurrentElement = mLastKnownElement;

  while (mpCurrentHandler == NULL)
    {
      mCurrentElement++; /* We should always be on the next element */

      switch (mCurrentElement)
        {
          case TEMPLATE:

            if (strcmp(pszName, "TEMPLATE"))
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "TEMPLATE", mParser.getCurrentLineNumber());

            mLastKnownElement = TEMPLATE;

            // Element specific code.
            return;

          case etc:

            if (!strcmp(pszName, "etc"))
              {
                /* If we do not have an etc element handler we create one. */
                if (!mpetcElement)
                  mpetcElement = new etcElement(mParser, mCommon);

                mpCurrentHandler = mpetcElement;
              }
            // Optional
            else
              {
                CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                               pszName, "etc", mParser.getCurrentLineNumber());
              }

            break;

          default:
            mCurrentElement = UNKNOWN_ELEMENT;
            mpCurrentHandler = &mParser.mUnknownElement;
            break;
        }
    }

  mParser.pushElementHandler(mpCurrentHandler);

  if (mpCurrentHandler != &mParser.mUnknownElement)
    {
      mLastKnownElement = mCurrentElement;
    }

  mParser.onStartElement(pszName, papszAttrs);

  return;
}

void CCopasiXMLParser::TEMPLATEElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case TEMPLATE:

        if (strcmp(pszName, "TEMPLATE"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "TEMPLATE", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mLastKnownElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case etc:

        if (strcmp(pszName, "etc"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "etc", mParser.getCurrentLineNumber());

        // Element specific code

        break;

      case UNKNOWN_ELEMENT:
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  mCurrentElement = TEMPLATE;
  return;
}

#endif // COPASI_TEMPLATE

CCopasiXMLParser::CCopasiXMLParser(CVersion & version) :
  CExpat(),
  mCommon(),
  mCharacterData(),
  mCharacterDataEncoding(CCopasiXMLInterface::none),
  mElementHandlerStack(),
  mUnknownElement(*this, this->mCommon),
  mCharacterDataElement(*this, this->mCommon),
  mListOfUnsupportedAnnotationsElement(*this, this->mCommon),
  mCommentElement(*this, this->mCommon),
  mMiriamAnnotationElement(*this, this->mCommon)
  // Attributes
{
  create();

  mElementHandlerStack.push(new COPASIElement(*this, mCommon));

  //  mCommon.pParser = this;
  mCommon.pVersion = & version;
  mCommon.pModel = NULL;
  mCommon.pFunctionList = NULL;
  mCommon.pFunction = NULL;
  mCommon.pTaskList = NULL;
  mCommon.pReportList = NULL;
  mCommon.pReport = NULL;
  mCommon.mParameterGroupLevel = -1;
  mCommon.pGUI = NULL;

  mCommon.pPlotList = NULL;
  mCommon.UnmappedKeyParameters.clear();

  mCommon.pLayoutList = NULL;
  mCommon.pCurrentLayout = NULL;
  mCommon.pCompartmentGlyph = NULL;
  mCommon.pMetaboliteGlyph = NULL;
  mCommon.pReactionGlyph = NULL;
  mCommon.pTextGlyph = NULL;
  //mCommon.pAdditionalGO = NULL;
  mCommon.pGeneralGlyph = NULL;
  mCommon.pCurve = NULL;
  mCommon.pLineSegment = NULL;
  mCommon.pMetaboliteReferenceGlyph = NULL;
  mCommon.pRenderInformation = NULL;
  mCommon.pGradient = NULL;
  mCommon.pLineEnding = NULL;
  mCommon.pStyle = NULL;
  mCommon.pGroup = NULL;
  mCommon.pText = NULL;
  mCommon.pListOfCurveElements = NULL;

  enableElementHandler(true);
}

CCopasiXMLParser::~CCopasiXMLParser()
{
  // We need to destruct the top most element on the stack since it has been
  // allocated in the constructor.
  if (mElementHandlerStack.empty())
    return;

  while (mElementHandlerStack.size() > 1)
    mElementHandlerStack.pop();

  delete mElementHandlerStack.top();
}

void CCopasiXMLParser::onStartElement(const XML_Char *pszName,
                                      const XML_Char **papszAttrs)
{
  assert(mElementHandlerStack.size() != 0);
  mElementHandlerStack.top()->start(pszName, papszAttrs);
}

void CCopasiXMLParser::onEndElement(const XML_Char *pszName)
{
  if (mElementHandlerStack.size() != 0)
    mElementHandlerStack.top()->end(pszName);
  else
    return;
}

#ifdef XXXX
void CCopasiXMLParser::onStartCdataSection()
{
  long i = mParser.getCurrentByteIndex();
}

void CCopasiXMLParser::onEndCdataSection()
{
  long i = mParser.getCurrentByteIndex();
}
#endif // XXXX

/**
 * Skipped entity handler
 * This is called in two situations:
 * 1) An entity reference is encountered for which no declaration
 *    has been read *and* this is not an error.
 * 2) An internal entity reference is read, but not expanded, because
 *    XML_SetDefaultHandler has been called.
 * Note: skipped parameter entities in declarations and skipped general
 *       entities in attribute values cannot be reported, because
 *       the event would be out of sync with the reporting of the
 *       declarations or attribute values
 * @param const XML_Char *entityName
 * @param int is_parameter_entity
 */
void CCopasiXMLParser::onSkippedEntityHandler(const XML_Char * entityName,
    int is_parameter_entity)
{
  mCharacterData += "&";
  mCharacterData += entityName;
  mCharacterData += ";";

  return;
}

void CCopasiXMLParser::enableCharacterDataHandler(bool fEnable)
{
  mCharacterData.erase();
  CExpat::enableCharacterDataHandler(fEnable);
}

void CCopasiXMLParser::onCharacterData(const XML_Char *pszData,
                                       int nLength)
{
  std::string Data;
  Data.append(pszData, nLength);

  mCharacterData += CCopasiXMLInterface::encode(Data, mCharacterDataEncoding);
}

std::string CCopasiXMLParser::getCharacterData(const std::string & toBeStripped,
    const std::string & join)
{
  std::string tmp(mCharacterData);

  enableCharacterDataHandler(false); /* Resetting for future calls. */

  if (toBeStripped == "") return tmp;

  std::string::size_type Start = tmp.find_first_of(toBeStripped);
  std::string::size_type End = 0;

  while (Start != std::string::npos)
    {
      End = tmp.find_first_not_of(toBeStripped, Start);

      tmp.erase(Start, End - Start);

      if (Start && End != std::string::npos)
        {
          tmp.insert(Start, join);
          Start += join.length();
        }

      Start = tmp.find_first_of(toBeStripped, Start);
    }

  return tmp;
}

void CCopasiXMLParser::pushElementHandler(CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon > * elementHandler)
{mElementHandlerStack.push(elementHandler);}

void CCopasiXMLParser::popElementHandler()
{mElementHandlerStack.pop();}

void CCopasiXMLParser::setFunctionList(CCopasiVectorN< CFunction > * pFunctionList)
{mCommon.pFunctionList = pFunctionList;}

CModel * CCopasiXMLParser::getModel() const
{return mCommon.pModel;}

CReportDefinitionVector * CCopasiXMLParser::getReportList() const
{return mCommon.pReportList;}

CCopasiVectorN< CCopasiTask > * CCopasiXMLParser::getTaskList() const
{return mCommon.pTaskList;}

COutputDefinitionVector * CCopasiXMLParser::getPlotList() const
{return mCommon.pPlotList;}

void CCopasiXMLParser::setGUI(SCopasiXMLGUI * pGUI)
{mCommon.pGUI = pGUI;}

void CCopasiXMLParser::setLayoutList(CListOfLayouts * pLayoutList)
{mCommon.pLayoutList = pLayoutList;}

CListOfLayouts * CCopasiXMLParser::getLayoutList() const
{return mCommon.pLayoutList;}

const CCopasiParameterGroup * CCopasiXMLParser::getCurrentGroup() const
{return dynamic_cast< const CCopasiParameterGroup * >(mCommon.pCurrentParameter);}

const CCopasiObject * CCopasiXMLParser::getObjectFromName(const std::string & cn) const
{
  const CObjectInterface * pObject = NULL;
  CCopasiObjectName CN = CCopasiObjectName(cn).getRemainder();

  if (mCommon.pModel &&
      (pObject = mCommon.pModel->getObject(CN)))
    return static_cast< const CCopasiObject * >(pObject);

  if (mCommon.pTaskList &&
      (pObject = mCommon.pTaskList->getObject(CN)))
    return static_cast< const CCopasiObject * >(pObject);

  if (mCommon.pFunctionList &&
      (pObject = mCommon.pFunctionList->getObject(CN)))
    return static_cast< const CCopasiObject * >(pObject);

  return NULL;
}

CCopasiXMLParser::UnknownElement::UnknownElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common),
  mLineNumber(0)
{}

CCopasiXMLParser::UnknownElement::~UnknownElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::UnknownElement::start(const XML_Char * /*pszName*/ ,
    const XML_Char ** /* papszAttrs */)
{
  /* We count the level of subelements of the Unknown Element */
  mCurrentElement++;

  if (mCurrentElement == Unknown)
    {
      mLineNumber = mParser.getCurrentLineNumber();
    }

  return;
}

void CCopasiXMLParser::UnknownElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Unknown:
        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;
        {
          CCopasiMessage(CCopasiMessage::WARNING, MCXML + 3,
                         pszName, mLineNumber);
        }

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      default:
        mCurrentElement--;
        break;
    }

  return;
}

CCopasiXMLParser::COPASIElement::COPASIElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::COPASIElement::~COPASIElement() {deleteCurrentHandler();}

void CCopasiXMLParser::COPASIElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */
  mpCurrentHandler = NULL;

  const char * versionMajor;
  C_INT32 VersionMajor;
  const char * versionMinor;
  C_INT32 VersionMinor;
  const char * versionDevel;
  C_INT32 VersionDevel;
  bool CopasiSourcesModified = true;

  switch (mCurrentElement)
    {
      case COPASI:

        if (!strcmp(pszName, "COPASI"))
          {
            versionMajor = mParser.getAttributeValue("versionMajor", papszAttrs, "0");
            VersionMajor = strToInt(versionMajor);
            versionMinor = mParser.getAttributeValue("versionMinor", papszAttrs, "0");
            VersionMinor = strToInt(versionMinor);
            versionDevel = mParser.getAttributeValue("versionDevel", papszAttrs, "0");
            VersionDevel = strToInt(versionDevel);
            CopasiSourcesModified = mParser.toBool(mParser.getAttributeValue("copasiSourcesModified", papszAttrs, "true"));

            mCommon.pVersion->setVersion(VersionMajor, VersionMinor, VersionDevel, CopasiSourcesModified);

            return;
          }
        // We may have a configuration file which starts with a parameter group
        else if (!strcmp(pszName, "ParameterGroup"))
          {
            mpCurrentHandler = new ParameterGroupElement(mParser, mCommon);
          }
        else
          {
            mpCurrentHandler = &mParser.mUnknownElement;

            CCopasiMessage(CCopasiMessage::WARNING, MCXML + 10,
                           pszName, "COPASI", mParser.getCurrentLineNumber());
          }

        break;

      case ListOfFunctions:

        if (!strcmp(pszName, "ListOfFunctions"))
          mpCurrentHandler = new ListOfFunctionsElement(mParser, mCommon);

        break;

      case Model:

        if (!strcmp(pszName, "Model"))
          mpCurrentHandler = new ModelElement(mParser, mCommon);

        break;

      case ListOfTasks:

        if (!strcmp(pszName, "ListOfTasks"))
          mpCurrentHandler = new ListOfTasksElement(mParser, mCommon);

        break;

      case ListOfReports:

        if (!strcmp(pszName, "ListOfReports"))
          mpCurrentHandler = new ListOfReportsElement(mParser, mCommon);

        break;

      case ListOfPlots:

        if (!strcmp(pszName, "ListOfPlots"))
          mpCurrentHandler = new ListOfPlotsElement(mParser, mCommon);

        break;

      case GUI:

        if (!strcmp(pszName, "GUI"))
          {
            if (mCommon.pGUI)
              mpCurrentHandler = new GUIElement(mParser, mCommon);
            else
              mpCurrentHandler = &mParser.mUnknownElement;
          }

        break;

      case ListOfLayouts:

        if (!strcmp(pszName, "ListOfLayouts"))
          mpCurrentHandler = new ListOfLayoutsElement(mParser, mCommon);

        break;

      case SBMLReference:

        if (!strcmp(pszName, "SBMLReference"))
          mpCurrentHandler = new SBMLReferenceElement(mParser, mCommon);

        break;

      default:
        mpCurrentHandler = &mParser.mUnknownElement;
        break;
    }

  if (mpCurrentHandler)
    mParser.pushElementHandler(mpCurrentHandler);

  mParser.onStartElement(pszName, papszAttrs);

  return;
}

void CCopasiXMLParser::COPASIElement::end(const XML_Char * pszName)
{
  if (!strcmp(pszName, "COPASI"))
    {
      mCurrentElement = START_ELEMENT;

      // We need to handle the unmapped parameters of type key.
      std::vector< std::string >::iterator it = mCommon.UnmappedKeyParameters.begin();
      std::vector< std::string >::iterator end = mCommon.UnmappedKeyParameters.end();

      for (; it != end; ++it)
        {
          CCopasiParameter * pParameter =
            dynamic_cast< CCopasiParameter * >(CCopasiRootContainer::getKeyFactory()->get(*it));

          if (pParameter != NULL &&
              pParameter->getType() == CCopasiParameter::KEY)
            {
              CCopasiObject * pObject =
                mCommon.KeyMap.get(*pParameter->getValue().pKEY);

              if (pObject != NULL)
                pParameter->setValue(pObject->getKey());
              else
                pParameter->setValue(std::string(""));
            }
        }

      // We need to remove the no longer needed expression "Objective Function" from the function list.
      if (mCommon.pFunctionList != NULL &&
          mCommon.pFunctionList->getIndex("Objective Function") != C_INVALID_INDEX)
        {
          mCommon.pFunctionList->remove("Objective Function");
        }

      return;
    }

  if (!strcmp(pszName, "ParameterGroup"))
    {
      mCurrentElement = START_ELEMENT;
    }
  else if (!strcmp(pszName, "GUI") && mCommon.pGUI == NULL)
    {
      CCopasiMessage::getLastMessage();
    }

  deleteCurrentHandler();

  //TODO why no case statement with error checking (like in other elements)?

  return;
}

CCopasiXMLParser::ListOfFunctionsElement::ListOfFunctionsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfFunctionsElement::~ListOfFunctionsElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfFunctionsElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfFunctions:

        if (strcmp(pszName, "ListOfFunctions"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfFunctions", mParser.getCurrentLineNumber());

        if (!mCommon.pFunctionList)
          mCommon.pFunctionList = new CCopasiVectorN< CFunction >;

        break;

      case Function:

        if (strcmp(pszName, "Function"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Function", mParser.getCurrentLineNumber());

        /* If we do not have a function element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new FunctionElement(mParser, mCommon);

        /* Push the Function element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfFunctionsElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfFunctions:

        if (strcmp(pszName, "ListOfFunctions"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfFunctions", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;
        {
          size_t i, imax = mCommon.pFunctionList->size();

          for (i = imax - 1; i != C_INVALID_INDEX; i--)
            {
              CFunction * pFunction =
                dynamic_cast<CFunction *>((*mCommon.pFunctionList)[i]);

              if (pFunction && !pFunction->compile())
                {
                  CCopasiMessage(CCopasiMessage::RAW, MCXML + 6,
                                 pFunction->getObjectName().c_str(),
                                 mParser.getCurrentLineNumber());
                  // We can keep the function as the compile is later checked again.
                  // mCommon.pFunctionList->CCopasiVector< CEvaluationTree >::remove(i);
                }
            }
        }

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Function:

        if (strcmp(pszName, "Function"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Function", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfFunctions;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::FunctionElement::FunctionElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common),
  mpMathMLElement(NULL),
  mpListOfParameterDescriptionsElement(NULL)
{}

CCopasiXMLParser::FunctionElement::~FunctionElement()
{
  pdelete(mpMathMLElement);
  pdelete(mpListOfParameterDescriptionsElement);
}

void CCopasiXMLParser::FunctionElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * type;
  CEvaluationTree::Type Type;
  const char * Name;
  const char * Reversible;
  size_t Index;

  mpCurrentHandler = NULL;
  mCurrentElement = mLastKnownElement;

  while (mpCurrentHandler == NULL)
    {
      mCurrentElement++; /* We should always be on the next element */
      CEvaluationTree* pEvaluationTree = NULL;

      switch (mCurrentElement)
        {
          case Function:

            if (strcmp(pszName, "Function"))
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "Function", mParser.getCurrentLineNumber());

            mKey = mParser.getAttributeValue("key", papszAttrs);
            Name = mParser.getAttributeValue("name", papszAttrs);
            type = mParser.getAttributeValue("type", papszAttrs);
            Type = toEnum(type, CEvaluationTree::XMLType, CEvaluationTree::UserDefined);

            Reversible = mParser.getAttributeValue("reversible", papszAttrs, false);

            if (!Reversible) // We may have an old file format using positive
              Reversible = mParser.getAttributeValue("positive", papszAttrs, "unspecified");

            mLastKnownElement = Function;

            mCommon.mPredefinedFunction = false;
            mCommon.mFunctionParameterKeyMap.clear();
            mExistingFunctionIndex.clear();

            pEvaluationTree = CEvaluationTree::create(Type);

            if (Type == CEvaluationTree::Expression)
              {
                mCommon.pFunction = NULL;

                mCommon.mpExpression = static_cast< CExpression * >(pEvaluationTree);
                mCommon.mKey2ObjectiveFunction[mKey] = mCommon.mpExpression;
              }
            else
              {
                mCommon.mpExpression = NULL;

                mCommon.pFunction = static_cast<CFunction *>(pEvaluationTree);
                mCommon.pFunction->setObjectName(Name);

                if (!strcmp(Reversible, "true"))
                  mCommon.pFunction->setReversible(TriTrue);
                else if (!strcmp(Reversible, "false"))
                  mCommon.pFunction->setReversible(TriFalse);
                else
                  mCommon.pFunction->setReversible(TriUnspecified);

                Index = mCommon.pFunctionList->getIndex(Name);

                if (Index != C_INVALID_INDEX) // A function with that name exists.
                  {
                    mExistingFunctionIndex.insert(Index);

                    switch ((*mCommon.pFunctionList)[Index]->getType())
                      {
                        case CEvaluationTree::MassAction:

                          if (Type == CEvaluationTree::MassAction)
                            {
                              pdelete(mCommon.pFunction);
                              mCommon.pFunction = (*mCommon.pFunctionList)[Index];
                              mCommon.mPredefinedFunction = true;
                            }
                          else
                            {
                              size_t Counter = 0;
                              std::string NewName;

                              while (true)
                                {
                                  Counter++;
                                  std::ostringstream ss;
                                  ss << Name << " [" << Counter << "]";
                                  NewName = ss.str();
                                  Index = mCommon.pFunctionList->getIndex(NewName);

                                  if (Index == C_INVALID_INDEX)
                                    break;

                                  mExistingFunctionIndex.insert(Index);
                                }

                              mCommon.pFunction->setObjectName(NewName);
                            }

                          break;

                        case CEvaluationTree::PreDefined:

                          if (Type == CEvaluationTree::PreDefined)
                            {
                              pdelete(mCommon.pFunction);
                              mCommon.pFunction = (*mCommon.pFunctionList)[Index];
                              mCommon.mPredefinedFunction = true;
                            }
                          else
                            {
                              size_t Counter = 0;
                              std::string NewName;

                              while (true)
                                {
                                  Counter++;
                                  std::ostringstream ss;
                                  ss << Name << " [" << Counter << "]";
                                  NewName = ss.str();
                                  Index = mCommon.pFunctionList->getIndex(NewName);

                                  if (Index == C_INVALID_INDEX)
                                    break;

                                  mExistingFunctionIndex.insert(Index);
                                }

                              mCommon.pFunction->setObjectName(NewName);
                            }

                          break;

                        case CEvaluationTree::UserDefined:
                        case CEvaluationTree::Function:
                          // Create a unique name
                        {
                          size_t Counter = 0;
                          std::string NewName;

                          while (true)
                            {
                              Counter++;
                              std::ostringstream ss;
                              ss << Name << " [" << Counter << "]";
                              NewName = ss.str();
                              Index = mCommon.pFunctionList->getIndex(NewName);

                              if (Index == C_INVALID_INDEX)
                                break;

                              mExistingFunctionIndex.insert(Index);
                            }

                          mCommon.pFunction->setObjectName(NewName);
                        }

                        break;

                        default:
                          break;
                      }
                  }
              }

            return;

          case MiriamAnnotation:

            if (!strcmp(pszName, "MiriamAnnotation"))
              mpCurrentHandler = &mParser.mMiriamAnnotationElement;

            break;

          case Comment:

            if (!strcmp(pszName, "Comment"))
              mpCurrentHandler = &mParser.mCommentElement;

            break;

          case ListOfUnsupportedAnnotations:

            if (!strcmp(pszName, "ListOfUnsupportedAnnotations"))
              mpCurrentHandler = &mParser.mListOfUnsupportedAnnotationsElement;

            break;

          case Expression:

            if (!strcmp(pszName, "Expression"))
              mpCurrentHandler = &mParser.mCharacterDataElement;
            else if (!strcmp(pszName, "MathML"))
              {
                /* If we do not have a MathML element handler we create one. */
                if (!mpMathMLElement)
                  mpMathMLElement = new MathMLElement(mParser, mCommon);

                mCurrentElement = MathML;
                mpCurrentHandler = mpMathMLElement;
              }
            else
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "Expression", mParser.getCurrentLineNumber());

            break;

          case ListOfParameterDescriptions:

            if (strcmp(pszName, "ListOfParameterDescriptions"))
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "ListOfParameterDescriptions", mParser.getCurrentLineNumber());

            /* If we do not have a ListOfParameterDescriptions element handler we create one. */
            if (!mpListOfParameterDescriptionsElement)
              mpListOfParameterDescriptionsElement = new ListOfParameterDescriptionsElement(mParser, mCommon);

            /* Push the ListOfParameterDescriptions element handler on the stack and call it. */
            mpCurrentHandler = mpListOfParameterDescriptionsElement;
            break;

          default:
            mCurrentElement = UNKNOWN_ELEMENT;
            mpCurrentHandler = &mParser.mUnknownElement;
            break;
        }
    }

  mParser.pushElementHandler(mpCurrentHandler);

  if (mpCurrentHandler != &mParser.mUnknownElement)
    {
      mLastKnownElement = mCurrentElement;
    }

  mParser.onStartElement(pszName, papszAttrs);
}

void CCopasiXMLParser::FunctionElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Function:

        if (strcmp(pszName, "Function"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Function", mParser.getCurrentLineNumber());

        mLastKnownElement = START_ELEMENT;
        mParser.popElementHandler();

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);

        if (mCommon.pFunction != NULL)
          {
            if (!mCommon.mPredefinedFunction)
              {
                // TODOWe need to check whether any existing function with the same
                // name is identical

                std::set< size_t >::const_iterator it = mExistingFunctionIndex.begin();
                std::set< size_t >::const_iterator end = mExistingFunctionIndex.end();

                for (; it != end; ++it)
                  {
                    CFunction * pFunction = (*mCommon.pFunctionList)[*it];

                    if (*pFunction == *mCommon.pFunction)
                      {
                        pdelete(mCommon.pFunction);
                        mCommon.pFunction = (*mCommon.pFunctionList)[*it];

                        break;
                      }
                  }

                /* We have a new function and add it to the list */
                if (it == end)
                  {
                    mCommon.pFunctionList->add(mCommon.pFunction, true);
                  }
              }

            addFix(mKey , mCommon.pFunction);

            std::map< size_t, std::string >::const_iterator it = mCommon.mFunctionParameterKeyMap.begin();
            std::map< size_t, std::string >::const_iterator end = mCommon.mFunctionParameterKeyMap.end();

            for (; it != end; ++it)
              {
                addFix(it->second, mCommon.pFunction->getVariables()[it->first]);
              }
          }

        break;

      case MiriamAnnotation:

        if (strcmp(pszName, "MiriamAnnotation"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MiriamAnnotation", mParser.getCurrentLineNumber());

        if (mCommon.pFunction != NULL)
          {
            mCommon.pFunction->setMiriamAnnotation(mCommon.CharacterData, mCommon.pFunction->getKey(), mKey);
            mCommon.CharacterData = "";
          }

        break;

      case Comment:

        if (strcmp(pszName, "Comment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Comment", mParser.getCurrentLineNumber());

        if (mCommon.pFunction != NULL)
          {
            mCommon.pFunction->setNotes(mCommon.CharacterData);
            mCommon.CharacterData = "";
          }

        break;

      case ListOfUnsupportedAnnotations:

        if (strcmp(pszName, "ListOfUnsupportedAnnotations"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfUnsupportedAnnotations", mParser.getCurrentLineNumber());

        if (mCommon.pFunction != NULL)
          {
            mCommon.pFunction->getUnsupportedAnnotations() = mParser.mListOfUnsupportedAnnotationsElement.getUnsupportedAnnotations();
          }

        break;

      case Expression:

        if (strcmp(pszName, "Expression"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Expression", mParser.getCurrentLineNumber());

        if (mCommon.pFunction != NULL)
          {
            if (!mCommon.mPredefinedFunction)
              {
                // do not yet compile the function as it might depend on elements not
                // read yet
                mCommon.pFunction->setInfix(mCommon.CharacterData, false);
              }
          }
        else if (mCommon.mpExpression != NULL)
          {
            mCommon.mpExpression->setInfix(mCommon.CharacterData);
          }

        break;

      case ListOfParameterDescriptions:

        if (strcmp(pszName, "ListOfParameterDescriptions"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfParameterDescriptions", mParser.getCurrentLineNumber());

        break;

      case MathML:

        if (strcmp(pszName, "MathML"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MathML", mParser.getCurrentLineNumber());

        if (mCommon.pFunction != NULL)
          {
            if (!mCommon.mPredefinedFunction)
              mCommon.pFunction->setInfix(mCommon.CharacterData);
          }
        else if (mCommon.mpExpression != NULL)
          {
            mCommon.mpExpression->setInfix(mCommon.CharacterData);
          }

        // MathML is in place of Expression in old CopasiML files.
        mLastKnownElement = Expression;
        break;

      case UNKNOWN_ELEMENT:
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  mCurrentElement = Function;

  return;
}

CCopasiXMLParser::MathMLElement::MathMLElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::MathMLElement::~MathMLElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::MathMLElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case MathML:

        if (strcmp(pszName, "MathML"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "MathML", mParser.getCurrentLineNumber());

        break;

      case Text:

        if (strcmp(pszName, "Text"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Text", mParser.getCurrentLineNumber());

        /* If we do not have a function element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new CharacterDataElement(mParser, mCommon);

        /* Push the Function element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::MathMLElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case MathML:

        if (strcmp(pszName, "MathML"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MathML", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Text:

        if (strcmp(pszName, "Text"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Text", mParser.getCurrentLineNumber());

        mCurrentElement = MathML;

        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }
}

CCopasiXMLParser::CharacterDataElement::CharacterDataElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::CharacterDataElement::~CharacterDataElement()
{}

void CCopasiXMLParser::CharacterDataElement::start(const XML_Char *pszName,
    const XML_Char ** papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case CharacterData:
        mCurrentElementName = pszName;
        mParser.enableCharacterDataHandler(true);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::CharacterDataElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case CharacterData:

        if (strcmp(pszName, mCurrentElementName.c_str()))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, mCurrentElementName.c_str(), mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;
        mCommon.CharacterData = mParser.getCharacterData("\x0a\x0d\t", "");
        {
          std::string::size_type Start = mCommon.CharacterData.find_first_not_of(" ");

          if (Start == std::string::npos)
            mCommon.CharacterData = "";
          else
            {
              std::string::size_type End = mCommon.CharacterData.find_last_not_of(" ");

              if (End == std::string::npos)
                mCommon.CharacterData = mCommon.CharacterData.substr(Start);
              else
                mCommon.CharacterData = mCommon.CharacterData.substr(Start, End - Start + 1);
            }
        }
        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }
}

CCopasiXMLParser::ListOfParameterDescriptionsElement::ListOfParameterDescriptionsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfParameterDescriptionsElement::~ListOfParameterDescriptionsElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfParameterDescriptionsElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfParameterDescriptions:

        mCommon.mFunctionParameterKeyMap.clear();

        if (strcmp(pszName, "ListOfParameterDescriptions"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfParameterDescriptions", mParser.getCurrentLineNumber());

        if (mpCurrentHandler) mpCurrentHandler->reset();

        break;

      case ParameterDescription:

        if (strcmp(pszName, "ParameterDescription"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ParameterDescription", mParser.getCurrentLineNumber());

        /* If we do not have a ParameterDescription element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new ParameterDescriptionElement(mParser, mCommon);

        /* Push the ParameterDescription element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfParameterDescriptionsElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfParameterDescriptions:

        if (strcmp(pszName, "ListOfParameterDescriptions"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfParameterDescriptions", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        // We need to remove all parameters which have been temporarily added to the list of variables
        {
          CFunction * pFunction = dynamic_cast<CFunction *>(mCommon.pFunction);

          if (pFunction)
            {
              CFunctionParameters & Variables = pFunction->getVariables();
              size_t i = Variables.size() - 1;

              for (; i != C_INVALID_INDEX && Variables[i]->getUsage() == CFunctionParameter::TEMPORARY; i--)
                Variables.remove(Variables[i]->getObjectName());
            }
        }
        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case ParameterDescription:

        if (strcmp(pszName, "ParameterDescription"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ParameterDescription", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfParameterDescriptions;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ParameterDescriptionElement::ParameterDescriptionElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common),
  mOrder(0)
{}

CCopasiXMLParser::ParameterDescriptionElement::~ParameterDescriptionElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ParameterDescriptionElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Key;
  const char * Name;
  const char * order;
  unsigned C_INT32 Order;
  const char * role; /*substrate, product, modifier, constant, other*/
  CFunctionParameter::Role Role;
  const char * minOccurs;
  unsigned C_INT32 MinOccurs;
  const char * maxOccurs;
  unsigned C_INT32 MaxOccurs;

  mCurrentElement++; /* We should always be on the next element */

  //std::string Usage[] = {"SUBSTRATE", "PRODUCT", "MODIFIER", "PARAMETER"};
  CFunctionParameter * pParm = NULL;
  CFunction * pFunction = dynamic_cast<CFunction *>(mCommon.pFunction);

  if (!pFunction) mCurrentElement++;

  switch (mCurrentElement)
    {
      case ParameterDescription:

        if (strcmp(pszName, "ParameterDescription"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ParameterDescription", mParser.getCurrentLineNumber());

        Key = mParser.getAttributeValue("key", papszAttrs);
        Name = mParser.getAttributeValue("name", papszAttrs);

        order = mParser.getAttributeValue("order", papszAttrs);
        Order = (unsigned C_INT32) atoi(order);

        role = mParser.getAttributeValue("role", papszAttrs);
        Role = CFunctionParameter::xmlRole2Enum(role);
        //if (Role == "") fatalError();

        minOccurs = mParser.getAttributeValue("minOccurs", papszAttrs, "1");
        MinOccurs = strToUnsignedInt(minOccurs);

        maxOccurs = mParser.getAttributeValue("maxOccurs", papszAttrs , "1");

        if (std::string("unbounded") == std::string(maxOccurs))
          MaxOccurs = (unsigned C_INT32) - 1;
        else
          MaxOccurs = strToUnsignedInt(maxOccurs);

        if (mCommon.mPredefinedFunction)
          {
            addFix(Key, pFunction->getVariables()[Name]);
          }
        else
          {
            // If we are here we have a user defined function.
            // We need to check whether the variable exists within the function.
            CFunctionParameter::DataType DataType;
            size_t Index =
              pFunction->getVariables().findParameterByName(Name, DataType);

            bool isUsed = true;

            if (Index == C_INVALID_INDEX)
              {
                // We add the missing parameter and mark it as unused.
                pFunction->getVariables().add(Name,
                                              CFunctionParameter::FLOAT64,
                                              Role);

                Index = pFunction->getVariables().findParameterByName(Name, DataType);
                isUsed = false;
              }

            // Make sure that we have enough parameter to swap
            size_t Counter = 0;

            while (Order >= pFunction->getVariables().size())
              {
                std::string NewName = StringPrint("TMP_%d", Counter++);

                while (!pFunction->getVariables().add(NewName,
                                                      CFunctionParameter::FLOAT64,
                                                      CFunctionParameter::TEMPORARY)) {};

                NewName = StringPrint("TMP_%d", Counter++);
              }

            // Assure that the order is correct
            if (Order != Index)
              pFunction->getVariables().swap(Order, Index);

            pParm = pFunction->getVariables()[Order];
            pParm->setObjectName(Name);
            pParm->setUsage(Role);
            pParm->setIsUsed(isUsed);

            if (MaxOccurs == 1 && MinOccurs == 1)
              pParm->setType(CFunctionParameter::FLOAT64);
            else
              pParm->setType(CFunctionParameter::VFLOAT64);

            mCommon.mFunctionParameterKeyMap[Order] = Key;
          }

        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ParameterDescriptionElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ParameterDescription:

        if (strcmp(pszName, "ParameterDescription"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ParameterDescription", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

void CCopasiXMLParser::ParameterDescriptionElement::reset()
{mOrder = 0;}

CCopasiXMLParser::ModelElement::ModelElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ModelElement::~ModelElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ModelElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Name;
  const char * timeUnit;
  CModel::TimeUnit TimeUnit;
  const char * volumeUnit;
  CModel::VolumeUnit VolumeUnit;
  const char * areaUnit;
  CModel::AreaUnit AreaUnit;
  const char * lengthUnit;
  CModel::LengthUnit LengthUnit;
  const char * quantityUnit;
  CModel::QuantityUnit QuantityUnit;
  CModel::ModelType ModelType;
  C_FLOAT64 Avogadro;

  mpCurrentHandler = NULL;
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case Model:

        if (strcmp(pszName, "Model"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Model", mParser.getCurrentLineNumber());

        mKey = mParser.getAttributeValue("key", papszAttrs);
        Name = mParser.getAttributeValue("name", papszAttrs);

        timeUnit = mParser.getAttributeValue("timeUnit", papszAttrs);
        TimeUnit = toEnum(timeUnit, CModel::TimeUnitNames, CModel::OldMinute);

        if (TimeUnit == CModel::OldMinute)
          {
            if (strcmp(timeUnit, "m"))
              TimeUnit = CModel::s;
            else
              TimeUnit = CModel::min;
          }

        volumeUnit = mParser.getAttributeValue("volumeUnit", papszAttrs);
        VolumeUnit = toEnum(volumeUnit, CModel::VolumeUnitNames, CModel::ml);

        //the next 2 attributes are introduced in Build 31, they have a default for
        //reading older cps files
        areaUnit = mParser.getAttributeValue("areaUnit", papszAttrs, "m\xc2\xb2");
        AreaUnit = toEnum(areaUnit, CModel::AreaUnitNames, CModel::m2);

        lengthUnit = mParser.getAttributeValue("lengthUnit", papszAttrs, "m");
        LengthUnit = toEnum(lengthUnit, CModel::LengthUnitNames, CModel::m);

        quantityUnit = mParser.getAttributeValue("quantityUnit", papszAttrs);
        QuantityUnit = toEnum(quantityUnit, CModel::QuantityUnitNames, CModel::OldXML);

        if (QuantityUnit == CModel::OldXML)
          QuantityUnit = toEnum(quantityUnit, CModel::QuantityUnitOldXMLNames, CModel::mMol);

        ModelType = toEnum(mParser.getAttributeValue("type", papszAttrs, "deterministic"),
                           CModel::ModelTypeNames, CModel::deterministic);

        Avogadro = CCopasiXMLInterface::DBL(mParser.getAttributeValue("avogadroConstant", papszAttrs, "6.0221415e23"));

        if (!mCommon.pModel) mCommon.pModel = new CModel(mCommon.pDataModel);

        // We remove the default parameter set:
        mCommon.pModel->getModelParameterSets().CCopasiVector< CModelParameterSet >::remove((size_t) 0);

        addFix(mKey, mCommon.pModel);
        mCommon.pModel->setObjectName(Name);
        mCommon.pModel->setTimeUnit(TimeUnit);
        mCommon.pModel->setVolumeUnit(VolumeUnit);
        mCommon.pModel->setAreaUnit(AreaUnit);
        mCommon.pModel->setLengthUnit(LengthUnit);
        mCommon.pModel->setQuantityUnit(QuantityUnit);
        mCommon.pModel->setModelType(ModelType);
        mCommon.pModel->setAvogadro(Avogadro);

        return;
        break;

      case MiriamAnnotation:

        if (!strcmp(pszName, "MiriamAnnotation"))
          {
            mpCurrentHandler = &mParser.mMiriamAnnotationElement;
            mLastKnownElement = mCurrentElement;
          }

        break;

      case Comment:

        if (!strcmp(pszName, "Comment"))
          {
            mpCurrentHandler = &mParser.mCommentElement;
            mLastKnownElement = mCurrentElement;
          }

        break;

      case ListOfUnsupportedAnnotations:

        if (!strcmp(pszName, "ListOfUnsupportedAnnotations"))
          {
            mpCurrentHandler = &mParser.mListOfUnsupportedAnnotationsElement;
            mLastKnownElement = mCurrentElement;
          }

        break;

      case InitialExpression:

        if (!strcmp(pszName, "InitialExpression"))
          {
            mpCurrentHandler = &mParser.mCharacterDataElement;
            mLastKnownElement = mCurrentElement;
          }

        break;

      case ListOfCompartments:

        if (!strcmp(pszName, "ListOfCompartments"))
          {
            mpCurrentHandler = new ListOfCompartmentsElement(mParser, mCommon);
            mLastKnownElement = mCurrentElement;
          }

        break;

      case ListOfMetabolites:

        if (!strcmp(pszName, "ListOfMetabolites"))
          {
            mpCurrentHandler = new ListOfMetabolitesElement(mParser, mCommon);
            mLastKnownElement = mCurrentElement;
          }

        break;

      case ListOfModelValues:

        if (!strcmp(pszName, "ListOfModelValues"))
          {
            mpCurrentHandler = new ListOfModelValuesElement(mParser, mCommon);
            mLastKnownElement = mCurrentElement;
          }

        break;

      case ListOfReactions:

        if (!strcmp(pszName, "ListOfReactions"))
          {
            mpCurrentHandler = new ListOfReactionsElement(mParser, mCommon);
            mLastKnownElement = mCurrentElement;
          }

        break;

      case ListOfEvents:

        if (!strcmp(pszName, "ListOfEvents"))
          {
            mpCurrentHandler = new ListOfEventsElement(mParser, mCommon);
            mLastKnownElement = mCurrentElement;
          }

        break;

      case ListOfModelParameterSets:

        if (!strcmp(pszName, "ListOfModelParameterSets"))
          {
            mpCurrentHandler = new ListOfModelParameterSetsElement(mParser, mCommon);
            mLastKnownElement = mCurrentElement;
          }

        break;

      case StateTemplate:

        if (!strcmp(pszName, "StateTemplate"))
          {
            mpCurrentHandler = new StateTemplateElement(mParser, mCommon);
            mLastKnownElement = mCurrentElement;
          }

        break;

      case InitialState:

        if (!strcmp(pszName, "InitialState"))
          {
            mpCurrentHandler = new InitialStateElement(mParser, mCommon);
            mLastKnownElement = mCurrentElement;
          }

        break;

      default:
        mCurrentElement = UNKNOWN_ELEMENT;
        mpCurrentHandler =  &mParser.mUnknownElement;
        break;
    }

  if (mpCurrentHandler)
    mParser.pushElementHandler(mpCurrentHandler);

  mParser.onStartElement(pszName, papszAttrs);

  return;
}

void CCopasiXMLParser::ModelElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Model:

        if (strcmp(pszName, "Model"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Model", mParser.getCurrentLineNumber());

        mCommon.pModel->setCompileFlag(true);

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case MiriamAnnotation:

        if (strcmp(pszName, "MiriamAnnotation"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MiriamAnnotation", mParser.getCurrentLineNumber());

        mCommon.pModel->setMiriamAnnotation(mCommon.CharacterData, mCommon.pModel->getKey(), mKey);
        mCommon.CharacterData = "";
        break;

      case Comment:

        if (strcmp(pszName, "Comment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Comment", mParser.getCurrentLineNumber());

        mCommon.pModel->setNotes(mCommon.CharacterData);
        mCommon.CharacterData = "";
        break;

      case ListOfUnsupportedAnnotations:

        if (strcmp(pszName, "ListOfUnsupportedAnnotations"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfUnsupportedAnnotations", mParser.getCurrentLineNumber());

        mCommon.pModel->getUnsupportedAnnotations() = mParser.mListOfUnsupportedAnnotationsElement.getUnsupportedAnnotations();
        break;

      case InitialExpression:

        if (strcmp(pszName, "InitialExpression"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "InitialExpression", mParser.getCurrentLineNumber());

        {
          size_t Size = CCopasiMessage::size();

          mCommon.pModel->setInitialExpression(mCommon.CharacterData);

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.
          while (CCopasiMessage::size() > Size)
            CCopasiMessage::getLastMessage();
        }

        // Old CopasiML files have the incorrect order and the comment may appear after
        // the initial expression. Therefore, we reset to MiriamAnnotation.
        mCurrentElement = MiriamAnnotation;
        break;

      case ListOfCompartments:

        if (strcmp(pszName, "ListOfCompartments"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfCompartments", mParser.getCurrentLineNumber());

        deleteCurrentHandler();
        break;

      case ListOfMetabolites:

        if (strcmp(pszName, "ListOfMetabolites"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfMetabolites", mParser.getCurrentLineNumber());

        deleteCurrentHandler();
        break;

      case ListOfModelValues:

        if (strcmp(pszName, "ListOfModelValues"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfModelValues", mParser.getCurrentLineNumber());

        deleteCurrentHandler();
        break;

      case ListOfReactions:

        if (strcmp(pszName, "ListOfReactions"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfReactions", mParser.getCurrentLineNumber());

        deleteCurrentHandler();
        break;

      case ListOfEvents:

        if (strcmp(pszName, "ListOfEvents"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfEvents", mParser.getCurrentLineNumber());

        deleteCurrentHandler();
        break;

      case ListOfModelParameterSets:

        if (strcmp(pszName, "ListOfModelParameterSets"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfModelParameterSets", mParser.getCurrentLineNumber());

        deleteCurrentHandler();
        mCurrentElement = Model; // This is possibly the last element.
        break;

      case StateTemplate:

        if (strcmp(pszName, "StateTemplate"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "StateTemplate", mParser.getCurrentLineNumber());

        deleteCurrentHandler();
        break;

      case InitialState:

        if (strcmp(pszName, "InitialState"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "InitialState", mParser.getCurrentLineNumber());

        deleteCurrentHandler();
        mCurrentElement = Model; // This is possibly the last element.
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        mCurrentElement = Model; // This is possibly the last element.
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::CommentElement::CommentElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common),
  mXhtml(),
  mLevel(0)
{}

CCopasiXMLParser::CommentElement::~CommentElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::CommentElement::start(const XML_Char *pszName,
    const XML_Char ** papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */
  const XML_Char ** ppAttrs;

  if (mLevel) mCurrentElement = xhtml;

  switch (mCurrentElement)
    {
      case Comment:

        if (strcmp(pszName, "Comment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Comment", mParser.getCurrentLineNumber());

        mXhtml.str("");
        mLevel = 0;
        mParser.enableCharacterDataHandler();
        mParser.enableSkippedEntityHandler();
        mParser.mCharacterDataEncoding = CCopasiXMLInterface::standard;

        mElementEmpty.push(false);
        break;

      case xhtml:

        if (mElementEmpty.top() == true)
          {
            mXhtml << ">";
            mElementEmpty.top() = false;
          }

        mXhtml << CCopasiXMLInterface::encode(mParser.getCharacterData());
        mXhtml << "<" << pszName;

        for (ppAttrs = papszAttrs; *ppAttrs && **ppAttrs; ppAttrs += 2)
          mXhtml << " " << *ppAttrs << "=\""
                 << CCopasiXMLInterface::encode(*(ppAttrs + 1), CCopasiXMLInterface::attribute) << "\"";

        mLevel++;
        mElementEmpty.push(true);

        mParser.enableCharacterDataHandler();
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::CommentElement::end(const XML_Char *pszName)
{
  std::string Xhtml;

  switch (mCurrentElement)
    {
      case Comment:

        if (strcmp(pszName, "Comment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Comment", mParser.getCurrentLineNumber());

        mXhtml << mParser.getCharacterData();

        mCommon.CharacterData = mXhtml.str();

        {
          // remove leading whitepsaces
          std::string::size_type pos = mCommon.CharacterData.find_first_not_of("\x0a\x0d\t ");

          if (pos != 0) mCommon.CharacterData.erase(0, pos);

          // remove trailing whitepsace
          pos = mCommon.CharacterData.find_last_not_of("\x0a\x0d\t ");

          if (pos < mCommon.CharacterData.length())
            mCommon.CharacterData = mCommon.CharacterData.substr(0, pos + 1);
        }

        mParser.enableSkippedEntityHandler(false);
        mParser.mCharacterDataEncoding = CCopasiXMLInterface::none;

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;
        mElementEmpty.pop();

        deleteCurrentHandler();

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case xhtml:
        Xhtml = mParser.getCharacterData();

        // Check whether and how we need to close the attribute
        if (mElementEmpty.top() == true)
          {
            if (Xhtml != "")
              {
                mElementEmpty.top() = false;
                mXhtml << ">";
              }
            else
              mXhtml << " />";
          }

        mXhtml << Xhtml;

        if (mElementEmpty.top() == false)
          mXhtml << "</" << pszName << ">";

        mElementEmpty.pop();
        mElementEmpty.top() = false;
        mLevel--;

        if (!mLevel) mCurrentElement = Comment;

        mParser.enableCharacterDataHandler();
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ListOfCompartmentsElement::ListOfCompartmentsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfCompartmentsElement::~ListOfCompartmentsElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfCompartmentsElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfCompartments:

        if (strcmp(pszName, "ListOfCompartments"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfCompartments", mParser.getCurrentLineNumber());

        mCommon.pModel->getCompartments().clear();
        break;

      case Compartment:

        if (strcmp(pszName, "Compartment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Compartment", mParser.getCurrentLineNumber());

        /* If we do not have a function element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new CompartmentElement(mParser, mCommon);

        /* Push the Compartment element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfCompartmentsElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfCompartments:

        if (strcmp(pszName, "ListOfCompartments"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfCompartments", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Compartment:

        if (strcmp(pszName, "Compartment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Compartment", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfCompartments;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::CompartmentElement::CompartmentElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common),
  mpCompartment(NULL)
{}

CCopasiXMLParser::CompartmentElement::~CompartmentElement()
{}

void CCopasiXMLParser::CompartmentElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Name;
  const char * simulationType;
  const char * Dimensionality;
  CModelEntity::Status SimulationType;

  mpCurrentHandler = NULL;
  mCurrentElement = mLastKnownElement;

  while (mpCurrentHandler == NULL)
    {
      mCurrentElement++; /* We should always be on the next element */

      switch (mCurrentElement)
        {
          case Compartment:

            if (strcmp(pszName, "Compartment"))
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "Compartment", mParser.getCurrentLineNumber());

            mKey = mParser.getAttributeValue("key", papszAttrs);
            Name = mParser.getAttributeValue("name", papszAttrs);
            simulationType = mParser.getAttributeValue("simulationType", papszAttrs, "fixed");
            SimulationType = toEnum(simulationType, CModelEntity::XMLStatus, CModel::FIXED);
            Dimensionality = mParser.getAttributeValue("dimensionality", papszAttrs, "3");

            mpCompartment = new CCompartment();
            addFix(mKey, mpCompartment);

            mpCompartment->setObjectName(Name);
            mpCompartment->setStatus(SimulationType);
            mpCompartment->setDimensionality(strToUnsignedInt(Dimensionality));

            mCommon.pModel->getCompartments().add(mpCompartment, true);
            mLastKnownElement = Compartment;
            return;

          case MiriamAnnotation:

            if (!strcmp(pszName, "MiriamAnnotation"))
              mpCurrentHandler = &mParser.mMiriamAnnotationElement;

            break;

          case Comment:

            if (!strcmp(pszName, "Comment"))
              mpCurrentHandler = &mParser.mCommentElement;

            break;

          case ListOfUnsupportedAnnotations:

            if (!strcmp(pszName, "ListOfUnsupportedAnnotations"))
              mpCurrentHandler = &mParser.mListOfUnsupportedAnnotationsElement;

            break;

          case Expression:

            if (!strcmp(pszName, "Expression"))
              mpCurrentHandler = &mParser.mCharacterDataElement;

            break;

          case InitialExpression:

            if (!strcmp(pszName, "InitialExpression"))
              mpCurrentHandler = &mParser.mCharacterDataElement;

            break;

          default:
            mCurrentElement = UNKNOWN_ELEMENT;
            mpCurrentHandler = &mParser.mUnknownElement;
            break;
        }
    }

  mParser.pushElementHandler(mpCurrentHandler);

  if (mpCurrentHandler != &mParser.mUnknownElement)
    {
      mLastKnownElement = mCurrentElement;
    }

  mParser.onStartElement(pszName, papszAttrs);

  return;
}

void CCopasiXMLParser::CompartmentElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Compartment:

        if (strcmp(pszName, "Compartment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Compartment", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mLastKnownElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case MiriamAnnotation:

        if (strcmp(pszName, "MiriamAnnotation"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MiriamAnnotation", mParser.getCurrentLineNumber());

        mpCompartment->setMiriamAnnotation(mCommon.CharacterData, mpCompartment->getKey(), mKey);
        mCommon.CharacterData = "";
        break;

      case Comment:

        if (strcmp(pszName, "Comment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Comment", mParser.getCurrentLineNumber());

        mpCompartment->setNotes(mCommon.CharacterData);
        mCommon.CharacterData = "";
        break;

      case ListOfUnsupportedAnnotations:

        if (strcmp(pszName, "ListOfUnsupportedAnnotations"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfUnsupportedAnnotations", mParser.getCurrentLineNumber());

        mpCompartment->getUnsupportedAnnotations() = mParser.mListOfUnsupportedAnnotationsElement.getUnsupportedAnnotations();

        break;

      case Expression:

        if (strcmp(pszName, "Expression"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Expression", mParser.getCurrentLineNumber());

        {
          size_t Size = CCopasiMessage::size();

          mpCompartment->setExpression(mCommon.CharacterData);

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.
          while (CCopasiMessage::size() > Size)
            CCopasiMessage::getLastMessage();
        }
        break;

      case InitialExpression:

        if (strcmp(pszName, "InitialExpression"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "InitialExpression", mParser.getCurrentLineNumber());

        {
          size_t Size = CCopasiMessage::size();

          mpCompartment->setInitialExpression(mCommon.CharacterData);

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.
          while (CCopasiMessage::size() > Size)
            CCopasiMessage::getLastMessage();
        }

        break;

      case UNKNOWN_ELEMENT:
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  mCurrentElement = Compartment;
  return;
}

CCopasiXMLParser::ListOfMetabolitesElement::ListOfMetabolitesElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfMetabolitesElement::~ListOfMetabolitesElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfMetabolitesElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfMetabolites:

        if (strcmp(pszName, "ListOfMetabolites"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfMetabolites", mParser.getCurrentLineNumber());

        break;

      case Metabolite:

        if (strcmp(pszName, "Metabolite"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Metabolite", mParser.getCurrentLineNumber());

        /* If we do not have a function element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new MetaboliteElement(mParser, mCommon);

        /* Push the Metabolite element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfMetabolitesElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfMetabolites:

        if (strcmp(pszName, "ListOfMetabolites"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfMetabolites", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Metabolite:

        if (strcmp(pszName, "Metabolite"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Metabolite", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfMetabolites;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::MetaboliteElement::MetaboliteElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common),
  mpMetabolite(NULL)
{}

CCopasiXMLParser::MetaboliteElement::~MetaboliteElement()
{}

void CCopasiXMLParser::MetaboliteElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  CCompartment * pCompartment = NULL;
  const char * Name;
  const char * simulationType;
  CModelEntity::Status SimulationType;
  const char reactions[] = "reactions";
  const char * Compartment;

  mpCurrentHandler = NULL;
  mCurrentElement = mLastKnownElement;

  while (mpCurrentHandler == NULL)
    {
      mCurrentElement++; /* We should always be on the next element */

      switch (mCurrentElement)
        {
          case Metabolite:

            if (strcmp(pszName, "Metabolite"))
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "Metabolite", mParser.getCurrentLineNumber());

            mKey = mParser.getAttributeValue("key", papszAttrs);
            Name = mParser.getAttributeValue("name", papszAttrs);

            simulationType = mParser.getAttributeValue("simulationType", papszAttrs, false);

            // We need to handle old files which used the attribute status.
            if (!simulationType)
              {
                simulationType = mParser.getAttributeValue("status", papszAttrs, false);

                if (!simulationType) // status and simulationType are both missing
                  simulationType = mParser.getAttributeValue("simulationType", papszAttrs);
                else if (!strcmp(simulationType, "variable")) // reactions was named variable
                  simulationType = reactions;
              }

            SimulationType = toEnum(simulationType, CModelEntity::XMLStatus, CModelEntity::REACTIONS);
            Compartment = mParser.getAttributeValue("compartment", papszAttrs);

            mpMetabolite = new CMetab();
            addFix(mKey, mpMetabolite);
            mpMetabolite->setObjectName(Name);
            mpMetabolite->setStatus(SimulationType);

            pCompartment =
              dynamic_cast< CCompartment* >(mCommon.KeyMap.get(Compartment));

            if (!pCompartment) fatalError();

            pCompartment->addMetabolite(mpMetabolite);
            mCommon.pModel->getMetabolites().add(mpMetabolite);

            mLastKnownElement = mCurrentElement;
            return;

          case MiriamAnnotation:

            if (!strcmp(pszName, "MiriamAnnotation"))
              mpCurrentHandler = &mParser.mMiriamAnnotationElement;

            break;

          case Comment:

            if (!strcmp(pszName, "Comment"))
              {
                mpCurrentHandler = &mParser.mCommentElement;
                mLastKnownElement = mCurrentElement;
              }

            break;

          case ListOfUnsupportedAnnotations:

            if (!strcmp(pszName, "ListOfUnsupportedAnnotations"))
              mpCurrentHandler = &mParser.mListOfUnsupportedAnnotationsElement;

            break;

          case Expression:

            if (!strcmp(pszName, "Expression"))
              mpCurrentHandler = &mParser.mCharacterDataElement;

            break;

          case InitialExpression:

            if (!strcmp(pszName, "InitialExpression"))
              mpCurrentHandler = &mParser.mCharacterDataElement;

            break;

          default:
            mCurrentElement = UNKNOWN_ELEMENT;
            mpCurrentHandler = &mParser.mUnknownElement;
            break;
        }
    }

  mParser.pushElementHandler(mpCurrentHandler);

  if (mpCurrentHandler != &mParser.mUnknownElement)
    {
      mLastKnownElement = mCurrentElement;
    }

  mParser.onStartElement(pszName, papszAttrs);

  return;
}

void CCopasiXMLParser::MetaboliteElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Metabolite:

        if (strcmp(pszName, "Metabolite"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Metabolite", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mLastKnownElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case MiriamAnnotation:

        if (strcmp(pszName, "MiriamAnnotation"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MiriamAnnotation", mParser.getCurrentLineNumber());

        mpMetabolite->setMiriamAnnotation(mCommon.CharacterData, mpMetabolite->getKey(), mKey);
        mCommon.CharacterData = "";
        break;

      case Comment:

        if (strcmp(pszName, "Comment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Comment", mParser.getCurrentLineNumber());

        mpMetabolite->setNotes(mCommon.CharacterData);
        mCommon.CharacterData = "";
        break;

      case ListOfUnsupportedAnnotations:

        if (strcmp(pszName, "ListOfUnsupportedAnnotations"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfUnsupportedAnnotations", mParser.getCurrentLineNumber());

        mpMetabolite->getUnsupportedAnnotations() = mParser.mListOfUnsupportedAnnotationsElement.getUnsupportedAnnotations();

        break;

      case Expression:

        if (strcmp(pszName, "Expression"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Expression", mParser.getCurrentLineNumber());

        {
          size_t Size = CCopasiMessage::size();

          mpMetabolite->setExpression(mCommon.CharacterData);

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.
          while (CCopasiMessage::size() > Size)
            CCopasiMessage::getLastMessage();
        }

        break;

      case InitialExpression:

        if (strcmp(pszName, "InitialExpression"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "InitialExpression", mParser.getCurrentLineNumber());

        {
          size_t Size = CCopasiMessage::size();

          mpMetabolite->setInitialExpression(mCommon.CharacterData);

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.
          while (CCopasiMessage::size() > Size)
            CCopasiMessage::getLastMessage();
        }

        break;

      case UNKNOWN_ELEMENT:
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  mCurrentElement = Metabolite;
  return;
}

//****** TODO: ModelValues

CCopasiXMLParser::ListOfModelValuesElement::ListOfModelValuesElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfModelValuesElement::~ListOfModelValuesElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfModelValuesElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfModelValues:

        if (strcmp(pszName, "ListOfModelValues"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfModelValues", mParser.getCurrentLineNumber());

        break;

      case ModelValue:

        if (strcmp(pszName, "ModelValue"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ModelValue", mParser.getCurrentLineNumber());

        /* If we do not have a function element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new ModelValueElement(mParser, mCommon);

        /* Push the Metabolite element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfModelValuesElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfModelValues:

        if (strcmp(pszName, "ListOfModelValues"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfModelValues", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case ModelValue:

        if (strcmp(pszName, "ModelValue"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ModelValue", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfModelValues;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ModelValueElement::ModelValueElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common),
  mpMV(NULL),
  mpMathMLElement(NULL),
  mKey("")
{}

CCopasiXMLParser::ModelValueElement::~ModelValueElement()
{
  pdelete(mpMathMLElement);
}

void CCopasiXMLParser::ModelValueElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Name;
  const char * simulationType;
  CModelEntity::Status SimulationType;

  mpCurrentHandler = NULL;
  mCurrentElement = mLastKnownElement;

  while (mpCurrentHandler == NULL)
    {
      mCurrentElement++; /* We should always be on the next element */

      switch (mCurrentElement)
        {
          case ModelValue:

            if (strcmp(pszName, "ModelValue"))
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "ModelValue", mParser.getCurrentLineNumber());

            mKey = mParser.getAttributeValue("key", papszAttrs);
            Name = mParser.getAttributeValue("name", papszAttrs);
            simulationType = mParser.getAttributeValue("simulationType", papszAttrs, false);

            // We need to handle old files which used the attribute status.
            if (!simulationType)
              {
                simulationType = mParser.getAttributeValue("status", papszAttrs, false);

                if (!simulationType) // status and simulationType are both missing
                  simulationType = mParser.getAttributeValue("simulationType", papszAttrs);
              }

            SimulationType = toEnum(simulationType, CModelEntity::XMLStatus, CModelEntity::FIXED);

            mpMV = new CModelValue();
            addFix(mKey, mpMV);
            mpMV->setObjectName(Name);
            mpMV->setStatus(SimulationType);

            mCommon.pModel->getModelValues().add(mpMV, true);
            mLastKnownElement = mCurrentElement;

            return;

          case MiriamAnnotation:

            if (!strcmp(pszName, "MiriamAnnotation"))
              mpCurrentHandler = &mParser.mMiriamAnnotationElement;

            break;

          case Comment:

            if (!strcmp(pszName, "Comment"))
              mpCurrentHandler = &mParser.mCommentElement;

            break;

          case ListOfUnsupportedAnnotations:

            if (!strcmp(pszName, "ListOfUnsupportedAnnotations"))
              mpCurrentHandler = &mParser.mListOfUnsupportedAnnotationsElement;

            break;

          case Expression:

            if (!strcmp(pszName, "Expression"))
              mpCurrentHandler = &mParser.mCharacterDataElement;

            break;

          case InitialExpression:

            if (!strcmp(pszName, "InitialExpression"))
              mpCurrentHandler = &mParser.mCharacterDataElement;

            break;

          case MathML:                                                   // Old file format support

            if (!strcmp(pszName, "MathML"))
              {
                /* If we do not have a MathML element handler we create one. */
                if (!mpMathMLElement)
                  mpMathMLElement = new MathMLElement(mParser, mCommon);

                mpCurrentHandler = mpMathMLElement;
              }

            break;

          default:
            mCurrentElement = UNKNOWN_ELEMENT;
            mpCurrentHandler = &mParser.mUnknownElement;
            break;
        }
    }

  mParser.pushElementHandler(mpCurrentHandler);

  if (mpCurrentHandler != &mParser.mUnknownElement)
    {
      mLastKnownElement = mCurrentElement;
    }

  mParser.onStartElement(pszName, papszAttrs);

  return;
}

void CCopasiXMLParser::ModelValueElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ModelValue:

        if (strcmp(pszName, "ModelValue"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ModelValue", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mLastKnownElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case MiriamAnnotation:

        if (strcmp(pszName, "MiriamAnnotation"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MiriamAnnotation", mParser.getCurrentLineNumber());

        mpMV->setMiriamAnnotation(mCommon.CharacterData, mpMV->getKey(), mKey);
        mCommon.CharacterData = "";
        break;

      case Comment:

        if (strcmp(pszName, "Comment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Comment", mParser.getCurrentLineNumber());

        mpMV->setNotes(mCommon.CharacterData);
        mCommon.CharacterData = "";
        break;

      case ListOfUnsupportedAnnotations:

        if (strcmp(pszName, "ListOfUnsupportedAnnotations"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfUnsupportedAnnotations", mParser.getCurrentLineNumber());

        mpMV->getUnsupportedAnnotations() = mParser.mListOfUnsupportedAnnotationsElement.getUnsupportedAnnotations();

        break;

      case Expression:

        if (strcmp(pszName, "Expression"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Expression", mParser.getCurrentLineNumber());

        {
          size_t Size = CCopasiMessage::size();

          mpMV->setExpression(mCommon.CharacterData);

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.

          while (CCopasiMessage::size() > Size)
            CCopasiMessage::getLastMessage();
        }

        break;

      case InitialExpression:

        if (strcmp(pszName, "InitialExpression"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "InitialExpression", mParser.getCurrentLineNumber());

        {
          size_t Size = CCopasiMessage::size();

          mpMV->setInitialExpression(mCommon.CharacterData);

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.
          while (CCopasiMessage::size() > Size)
            CCopasiMessage::getLastMessage();
        }

        break;

      case MathML:                                                   // Old file format support

        if (strcmp(pszName, "MathML"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MathML", mParser.getCurrentLineNumber());

        {
          size_t Size = CCopasiMessage::size();

          mpMV->setExpression(mCommon.CharacterData);

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.

          while (CCopasiMessage::size() > Size)
            CCopasiMessage::getLastMessage();
        }

        break;

      case UNKNOWN_ELEMENT:
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  mCurrentElement = ModelValue;
  return;
}

//****** TODO: Event

CCopasiXMLParser::ListOfEventsElement::ListOfEventsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfEventsElement::~ListOfEventsElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfEventsElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfEvents:

        if (strcmp(pszName, "ListOfEvents"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfEvents", mParser.getCurrentLineNumber());

        mEventOrders.clear();
        break;

      case Event:

        if (strcmp(pszName, "Event"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Event", mParser.getCurrentLineNumber());

        /* If we do not have a function element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new EventElement(mParser, mCommon);

        /* Push the Metabolite element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfEventsElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfEvents:

        if (strcmp(pszName, "ListOfEvents"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfEvents", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Event:

        if (strcmp(pszName, "Event"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Event", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfEvents;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::EventElement::EventElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common),
  mpListOfAssignmentsElementHandler(NULL)
{}

CCopasiXMLParser::EventElement::~EventElement()
{
  pdelete(mpListOfAssignmentsElementHandler);
}

void CCopasiXMLParser::EventElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Name;
  bool DelayAssignment;
  bool FireAtInitialTime;
  bool PersistentTrigger;

  mpCurrentHandler = NULL;
  mCurrentElement = mLastKnownElement;

  while (mpCurrentHandler == NULL)
    {
      mCurrentElement++; /* We should always be on the next element */

      switch (mCurrentElement)
        {
          case Event:

            if (strcmp(pszName, "Event"))
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "Event", mParser.getCurrentLineNumber());

            mKey = mParser.getAttributeValue("key", papszAttrs);
            Name = mParser.getAttributeValue("name", papszAttrs);
            DelayAssignment =
              mParser.toBool(mParser.getAttributeValue("delayAssignment", papszAttrs, false));
            FireAtInitialTime =
              mParser.toBool(mParser.getAttributeValue("fireAtInitialTime", papszAttrs, false));

            if (mCommon.pVersion->getVersionDevel() <= 90)
              {
                PersistentTrigger = true;
              }
            else
              {
                PersistentTrigger = mParser.toBool(mParser.getAttributeValue("persistentTrigger", papszAttrs, true));
              }

            mCommon.pEvent = new CEvent();
            addFix(mKey, mCommon.pEvent);
            mCommon.pEvent->setObjectName(Name);
            mCommon.pEvent->setDelayAssignment(DelayAssignment);
            mCommon.pEvent->setFireAtInitialTime(FireAtInitialTime);
            mCommon.pEvent->setPersistentTrigger(PersistentTrigger);

            mCommon.pModel->getEvents().add(mCommon. pEvent, true);

            mLastKnownElement = Event;
            return;

          case MiriamAnnotation:

            if (!strcmp(pszName, "MiriamAnnotation"))
              mpCurrentHandler = &mParser.mMiriamAnnotationElement;

            break;

          case Comment:

            if (!strcmp(pszName, "Comment"))
              mpCurrentHandler = &mParser.mCommentElement;

            break;

          case ListOfUnsupportedAnnotations:

            if (!strcmp(pszName, "ListOfUnsupportedAnnotations"))
              mpCurrentHandler = &mParser.mListOfUnsupportedAnnotationsElement;

            break;

          case TriggerExpression:

            if (!strcmp(pszName, "TriggerExpression"))
              mpCurrentHandler = &mParser.mCharacterDataElement;

            break;

          case DelayExpression:

            if (!strcmp(pszName, "DelayExpression"))
              mpCurrentHandler = &mParser.mCharacterDataElement;

            break;

          case ListOfAssignments:

            if (!strcmp(pszName, "ListOfAssignments"))
              {
                if (!mpListOfAssignmentsElementHandler)
                  {
                    mpListOfAssignmentsElementHandler =
                      new ListOfAssignmentsElement(mParser, mCommon);

                    mCommon.mAssignments.reserve(100);
                    mCommon.mAssignments.resize(0);
                  }

                mpCurrentHandler = mpListOfAssignmentsElementHandler;
              }

            break;

          default:
            mCurrentElement = UNKNOWN_ELEMENT;
            mpCurrentHandler = &mParser.mUnknownElement;
            break;
        }
    }

  mParser.pushElementHandler(mpCurrentHandler);

  if (mpCurrentHandler != &mParser.mUnknownElement)
    {
      mLastKnownElement = mCurrentElement;
    }

  mParser.onStartElement(pszName, papszAttrs);

  return;
}

void CCopasiXMLParser::EventElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Event:

        if (strcmp(pszName, "Event"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Event", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mLastKnownElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case MiriamAnnotation:

        if (strcmp(pszName, "MiriamAnnotation"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MiriamAnnotation", mParser.getCurrentLineNumber());

        mCommon.pEvent->setMiriamAnnotation(mCommon.CharacterData, mCommon.pEvent->getKey(), mKey);
        mCommon.CharacterData = "";
        break;

      case Comment:

        if (strcmp(pszName, "Comment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Comment", mParser.getCurrentLineNumber());

        mCommon.pEvent->setNotes(mCommon.CharacterData);
        mCommon.CharacterData = "";
        break;

      case ListOfUnsupportedAnnotations:

        if (strcmp(pszName, "ListOfUnsupportedAnnotations"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfUnsupportedAnnotations", mParser.getCurrentLineNumber());

        mCommon.pEvent->getUnsupportedAnnotations() = mParser.mListOfUnsupportedAnnotationsElement.getUnsupportedAnnotations();

        break;

      case TriggerExpression:

        if (strcmp(pszName, "TriggerExpression"))
          {
            CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                           pszName, "TriggerExpression", mParser.getCurrentLineNumber());
          }

        {
          size_t Size = CCopasiMessage::size();

          mCommon.pEvent->setTriggerExpression(mCommon.CharacterData);

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.
          while (CCopasiMessage::size() > Size)
            {
              CCopasiMessage msg = CCopasiMessage::getLastMessage();
            }
        }

        break;

      case DelayExpression:

        if (strcmp(pszName, "DelayExpression"))
          {
            CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                           pszName, "DelayExpression", mParser.getCurrentLineNumber());
          }

        {
          size_t Size = CCopasiMessage::size();

          mCommon.pEvent->setDelayExpression(mCommon.CharacterData);

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.
          while (CCopasiMessage::size() > Size)
            {
              CCopasiMessage msg = CCopasiMessage::getLastMessage();
            }
        }

        break;

      case ListOfAssignments:
        break;

      case UNKNOWN_ELEMENT:
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  mCurrentElement = Event;
  return;
}

//****** TODO: Assignments

CCopasiXMLParser::ListOfAssignmentsElement::ListOfAssignmentsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfAssignmentsElement::~ListOfAssignmentsElement()
{deleteCurrentHandler();}

void CCopasiXMLParser::ListOfAssignmentsElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfAssignments:

        if (strcmp(pszName, "ListOfAssignments"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfAssignments", mParser.getCurrentLineNumber());

        break;

      case Assignment:

        if (strcmp(pszName, "Assignment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Assignment", mParser.getCurrentLineNumber());

        /* If we do not have a function element handler we create one. */
        if (!mpCurrentHandler)
          {
            mpCurrentHandler = new AssignmentElement(mParser, mCommon);
          }

        /* Push the Metabolite element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfAssignmentsElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfAssignments:

        if (strcmp(pszName, "ListOfAssignments"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfAssignments", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Assignment:

        if (strcmp(pszName, "Assignment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Assignment", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfAssignments;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::AssignmentElement::AssignmentElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::AssignmentElement::~AssignmentElement()
{deleteCurrentHandler();}

void CCopasiXMLParser::AssignmentElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mpCurrentHandler = NULL;
  mCurrentElement++; /* We should always be on the next element */

  const CModelEntity* pME = NULL;

  switch (mCurrentElement)
    {
      case Assignment:

        if (strcmp(pszName, "Assignment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Assignment", mParser.getCurrentLineNumber());

        mCommon.pEventAssignment = NULL;
        mKey = mParser.getAttributeValue("targetKey", papszAttrs);
        pME = dynamic_cast<const CModelEntity *>(mCommon.KeyMap.get(mKey));

        if (pME != NULL &&
            mCommon.pEvent->getAssignments().getIndex(pME->getKey()) == C_INVALID_INDEX)
          {
            mCommon.pEventAssignment = new CEventAssignment(pME->getKey());
            mCommon.pEvent->getAssignments().add(mCommon.pEventAssignment, true);
          }

        return;

      case Expression:

        if (!strcmp(pszName, "Expression"))
          {
            mpCurrentHandler = &mParser.mCharacterDataElement;
          }

        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mpCurrentHandler = &mParser.mUnknownElement;
        break;
    }

  if (mpCurrentHandler)
    mParser.pushElementHandler(mpCurrentHandler);

  mParser.onStartElement(pszName, papszAttrs);

  return;
}

void CCopasiXMLParser::AssignmentElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Assignment:

        if (strcmp(pszName, "Assignment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Assignment", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Expression:

        if (strcmp(pszName, "Expression"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Expression", mParser.getCurrentLineNumber());

        {
          size_t Size = CCopasiMessage::size();

          if (mCommon.pEventAssignment != NULL)
            mCommon.pEventAssignment->setExpression(mCommon.CharacterData);

          CCopasiMessage msg = CCopasiMessage::getLastMessage();

          // Remove error messages created by setExpression as this may fail
          // due to incomplete model specification at this time.
          while (CCopasiMessage::size() > Size)
            {
              msg = CCopasiMessage::getLastMessage();
            }
        }

        mCurrentElement = Assignment;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

//******

CCopasiXMLParser::ListOfReactionsElement::ListOfReactionsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfReactionsElement::~ListOfReactionsElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfReactionsElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfReactions:

        if (strcmp(pszName, "ListOfReactions"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfReactions", mParser.getCurrentLineNumber());

        mCommon.pModel->getReactions().clear();
        break;

      case Reaction:

        if (strcmp(pszName, "Reaction"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Reaction", mParser.getCurrentLineNumber());

        /* If we do not have a Reaction element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new ReactionElement(mParser, mCommon);

        /* Push the Reaction element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfReactionsElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfReactions:

        if (strcmp(pszName, "ListOfReactions"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfReactions", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Reaction:

        if (strcmp(pszName, "Reaction"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Reaction", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfReactions;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ReactionElement::ReactionElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common),
  mpListOfSubstratesElement(NULL),
  mpListOfProductsElement(NULL),
  mpListOfModifiersElement(NULL),
  mpListOfConstantsElement(NULL),
  mpKineticLawElement(NULL)
{}

CCopasiXMLParser::ReactionElement::~ReactionElement()
{
  pdelete(mpListOfSubstratesElement);
  pdelete(mpListOfProductsElement);
  pdelete(mpListOfModifiersElement);
  pdelete(mpListOfConstantsElement);
  pdelete(mpKineticLawElement);
}

void CCopasiXMLParser::ReactionElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  CCompartment * pCompartment;
  const char * Name;
  const char * Compartment; // Default Compartment_00
  const char * reversible;
  bool Reversible;
  const char * fast;
  bool Fast;
  const char * SBMLId;

  mCurrentElement = mLastKnownElement;
  mpCurrentHandler = NULL;

  while (mpCurrentHandler == NULL)
    {
      mCurrentElement++; /* We should always be on the next element */

      switch (mCurrentElement)
        {
          case Reaction:

            if (strcmp(pszName, "Reaction"))
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                             pszName, "Reaction", mParser.getCurrentLineNumber());

            mKey = mParser.getAttributeValue("key", papszAttrs);
            Name = mParser.getAttributeValue("name", papszAttrs);
            Compartment = mParser.getAttributeValue("compartment", papszAttrs,
                                                    "Compartment_00");

            reversible = mParser.getAttributeValue("reversible", papszAttrs);
            Reversible = mParser.toBool(reversible);

            fast = mParser.getAttributeValue("fast", papszAttrs, "false");
            Fast = mParser.toBool(fast);

            mCommon.pReaction = new CReaction();
            addFix(mKey, mCommon.pReaction);
            mCommon.pReaction->setObjectName(Name);
            mCommon.pReaction->setReversible(Reversible);
            mCommon.pReaction->setFast(Fast);
            SBMLId = mParser.getAttributeValue("sbmlid", papszAttrs, "");

            if (std::string(SBMLId) != std::string(""))
              {
                mCommon.pReaction->setSBMLId(SBMLId);
              }

            if (strcmp(Compartment, "Compartment_00")) //TODO necessary?
              {
                pCompartment =
                  dynamic_cast< CCompartment* >(mCommon.KeyMap.get(Compartment));

                if (!pCompartment) fatalError();

                //mCommon.pReaction->setCompartment(pCompartment);
              }

            mCommon.pModel->getReactions().add(mCommon.pReaction, true);

            mLastKnownElement = Reaction;
            return;
            break;

          case MiriamAnnotation:

            if (!strcmp(pszName, "MiriamAnnotation"))
              mpCurrentHandler = &mParser.mMiriamAnnotationElement;

            break;

          case Comment:

            if (!strcmp(pszName, "Comment"))
              {
                mpCurrentHandler = &mParser.mCommentElement;
                mLastKnownElement = mCurrentElement;
              }

            break;

          case ListOfUnsupportedAnnotations:

            if (!strcmp(pszName, "ListOfUnsupportedAnnotations"))
              mpCurrentHandler = &mParser.mListOfUnsupportedAnnotationsElement;

            break;

          case ListOfSubstrates:

            if (!strcmp(pszName, "ListOfSubstrates"))
              {
                /* If we do not have a function element handler we create one. */
                if (!mpListOfSubstratesElement)
                  mpListOfSubstratesElement =
                    new ListOfSubstratesElement(mParser, mCommon);

                mpCurrentHandler = mpListOfSubstratesElement;
              }

            break;

          case ListOfProducts:

            if (!strcmp(pszName, "ListOfProducts"))
              {
                if (!mpListOfProductsElement)
                  mpListOfProductsElement =
                    new ListOfProductsElement(mParser, mCommon);

                mpCurrentHandler = mpListOfProductsElement;
              }

            break;

          case ListOfModifiers:

            if (!strcmp(pszName, "ListOfModifiers"))
              {
                if (!mpListOfModifiersElement)
                  mpListOfModifiersElement =
                    new ListOfModifiersElement(mParser, mCommon);

                mpCurrentHandler = mpListOfModifiersElement;
              }

            break;

          case ListOfConstants:

            if (!strcmp(pszName, "ListOfConstants"))
              {
                if (!mpListOfConstantsElement)
                  mpListOfConstantsElement =
                    new ListOfConstantsElement(mParser, mCommon);

                mpCurrentHandler = mpListOfConstantsElement;
              }

            break;

          case KineticLaw:

            if (!strcmp(pszName, "KineticLaw"))
              {
                if (!mpKineticLawElement)
                  mpKineticLawElement = new KineticLawElement(mParser, mCommon);

                mpCurrentHandler = mpKineticLawElement;
              }

            break;

          default:
            mCurrentElement = UNKNOWN_ELEMENT;
            mpCurrentHandler = &mParser.mUnknownElement;
            break;
        }
    }

  mParser.pushElementHandler(mpCurrentHandler);

  if (mpCurrentHandler != &mParser.mUnknownElement)
    {
      mLastKnownElement = mCurrentElement;
    }

  mParser.onStartElement(pszName, papszAttrs);

  return;
}

void CCopasiXMLParser::ReactionElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Reaction:

        if (strcmp(pszName, "Reaction"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Reaction", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mLastKnownElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case MiriamAnnotation:

        if (strcmp(pszName, "MiriamAnnotation"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "MiriamAnnotation", mParser.getCurrentLineNumber());

        mCommon.pReaction->setMiriamAnnotation(mCommon.CharacterData, mCommon.pReaction->getKey(), mKey);
        mCommon.CharacterData = "";
        break;

      case Comment:

        if (strcmp(pszName, "Comment"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Comment", mParser.getCurrentLineNumber());

        mCommon.pReaction->setNotes(mCommon.CharacterData);
        mCommon.CharacterData = "";
        break;

      case ListOfUnsupportedAnnotations:

        if (strcmp(pszName, "ListOfUnsupportedAnnotations"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfUnsupportedAnnotations", mParser.getCurrentLineNumber());

        mCommon.pReaction->getUnsupportedAnnotations() = mParser.mListOfUnsupportedAnnotationsElement.getUnsupportedAnnotations();

        break;

      case ListOfSubstrates:

        if (strcmp(pszName, "ListOfSubstrates"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfSubstrates", mParser.getCurrentLineNumber());

        break;

      case ListOfProducts:

        if (strcmp(pszName, "ListOfProducts"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfProducts", mParser.getCurrentLineNumber());

        break;

      case ListOfModifiers:

        if (strcmp(pszName, "ListOfModifiers"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfModifiers", mParser.getCurrentLineNumber());

        break;

      case ListOfConstants:

        if (strcmp(pszName, "ListOfConstants"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfConstants", mParser.getCurrentLineNumber());

        break;

      case KineticLaw:

        if (strcmp(pszName, "KineticLaw"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "KineticLaw", mParser.getCurrentLineNumber());

        break;

      case UNKNOWN_ELEMENT:
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  mCurrentElement = Reaction;

  return;
}

CCopasiXMLParser::ListOfSubstratesElement::ListOfSubstratesElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfSubstratesElement::~ListOfSubstratesElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfSubstratesElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfSubstrates:

        if (strcmp(pszName, "ListOfSubstrates"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfSubstrates", mParser.getCurrentLineNumber());

        break;

      case Substrate:

        if (strcmp(pszName, "Substrate"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Substrate", mParser.getCurrentLineNumber());

        /* If we do not have a Substrate element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new SubstrateElement(mParser, mCommon);

        /* Push the Substrate element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfSubstratesElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfSubstrates:

        if (strcmp(pszName, "ListOfSubstrates"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfSubstrates", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Substrate:

        if (strcmp(pszName, "Substrate"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Substrate", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfSubstrates;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::SubstrateElement::SubstrateElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::SubstrateElement::~SubstrateElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::SubstrateElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Metabolite;
  CMetab * pMetabolite;

  const char * Stoichiometry;

  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case Substrate:

        if (strcmp(pszName, "Substrate"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Substrate", mParser.getCurrentLineNumber());

        Metabolite = mParser.getAttributeValue("metabolite", papszAttrs);
        Stoichiometry = mParser.getAttributeValue("stoichiometry", papszAttrs);

        pMetabolite = dynamic_cast< CMetab * >(mCommon.KeyMap.get(Metabolite));

        if (!pMetabolite) fatalError();

        mCommon.pReaction->addSubstrate(pMetabolite->getKey(),
                                        CCopasiXMLInterface::DBL(Stoichiometry));
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::SubstrateElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Substrate:

        if (strcmp(pszName, "Substrate"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Substrate", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ListOfProductsElement::ListOfProductsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfProductsElement::~ListOfProductsElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfProductsElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfProducts:

        if (strcmp(pszName, "ListOfProducts"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfProducts", mParser.getCurrentLineNumber());

        break;

      case Product:

        if (strcmp(pszName, "Product"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Product", mParser.getCurrentLineNumber());

        /* If we do not have a Product element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new ProductElement(mParser, mCommon);

        /* Push the Product element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfProductsElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfProducts:

        if (strcmp(pszName, "ListOfProducts"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfProducts", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Product:

        if (strcmp(pszName, "Product"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Product", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfProducts;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ProductElement::ProductElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ProductElement::~ProductElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ProductElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Metabolite;
  CMetab * pMetabolite;

  const char * Stoichiometry;

  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case Product:

        if (strcmp(pszName, "Product"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Product", mParser.getCurrentLineNumber());

        Metabolite = mParser.getAttributeValue("metabolite", papszAttrs);
        Stoichiometry = mParser.getAttributeValue("stoichiometry", papszAttrs);

        pMetabolite = dynamic_cast< CMetab * >(mCommon.KeyMap.get(Metabolite));

        if (!pMetabolite) fatalError();

        mCommon.pReaction->addProduct(pMetabolite->getKey(),
                                      CCopasiXMLInterface::DBL(Stoichiometry));
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ProductElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Product:

        if (strcmp(pszName, "Product"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Product", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ListOfModifiersElement::ListOfModifiersElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfModifiersElement::~ListOfModifiersElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfModifiersElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfModifiers:

        if (strcmp(pszName, "ListOfModifiers"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfModifiers", mParser.getCurrentLineNumber());

        break;

      case Modifier:

        if (strcmp(pszName, "Modifier"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Modifier", mParser.getCurrentLineNumber());

        /* If we do not have a Modifier element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new ModifierElement(mParser, mCommon);

        /* Push the Modifier element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfModifiersElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfModifiers:

        if (strcmp(pszName, "ListOfModifiers"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfModifiers", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Modifier:

        if (strcmp(pszName, "Modifier"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Modifier", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfModifiers;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ModifierElement::ModifierElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ModifierElement::~ModifierElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ModifierElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Metabolite;
  CMetab * pMetabolite;

  const char * Stoichiometry;

  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case Modifier:

        if (strcmp(pszName, "Modifier"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Modifier", mParser.getCurrentLineNumber());

        Metabolite = mParser.getAttributeValue("metabolite", papszAttrs);
        Stoichiometry = mParser.getAttributeValue("stoichiometry", papszAttrs);

        pMetabolite = dynamic_cast< CMetab * >(mCommon.KeyMap.get(Metabolite));

        if (!pMetabolite) fatalError();

        mCommon.pReaction->addModifier(pMetabolite->getKey(),
                                       CCopasiXMLInterface::DBL(Stoichiometry));
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ModifierElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Modifier:

        if (strcmp(pszName, "Modifier"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Modifier", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ListOfConstantsElement::ListOfConstantsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfConstantsElement::~ListOfConstantsElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfConstantsElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfConstants:

        if (strcmp(pszName, "ListOfConstants"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfConstants", mParser.getCurrentLineNumber());

        mCommon.pReaction->getParameters().clear();
        break;

      case Constant:

        if (strcmp(pszName, "Constant"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Constant", mParser.getCurrentLineNumber());

        /* If we do not have a Constant element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new ConstantElement(mParser, mCommon);

        /* Push the Constant element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfConstantsElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfConstants:

        if (strcmp(pszName, "ListOfConstants"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfConstants", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case Constant:

        if (strcmp(pszName, "Constant"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Constant", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfConstants;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ConstantElement::ConstantElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ConstantElement::~ConstantElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ConstantElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Key;
  const char * Name;
  const char * Value;

  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case Constant:

        if (strcmp(pszName, "Constant"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "Constant", mParser.getCurrentLineNumber());

        Key = mParser.getAttributeValue("key", papszAttrs);
        Name = mParser.getAttributeValue("name", papszAttrs);
        Value = mParser.getAttributeValue("value", papszAttrs);

        mCommon.pReaction->
        getParameters().addParameter(Name,
                                     CCopasiParameter::DOUBLE,
                                     (C_FLOAT64) CCopasiXMLInterface::DBL(Value));

        addFix(Key,
               mCommon.pReaction->getParameters().getParameter(Name));

        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ConstantElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case Constant:

        if (strcmp(pszName, "Constant"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "Constant", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::KineticLawElement::KineticLawElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::KineticLawElement::~KineticLawElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::KineticLawElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Function;

  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case KineticLaw:

        if (strcmp(pszName, "KineticLaw"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "KineticLaw", mParser.getCurrentLineNumber());

        Function = mParser.getAttributeValue("function", papszAttrs);

        mCommon.pFunction =
          dynamic_cast< CFunction* >(mCommon.KeyMap.get(Function));

        if (!mCommon.pFunction)
          {
            CCopasiMessage(CCopasiMessage::RAW, MCXML + 7, Function,
                           mCommon.pReaction->getObjectName().c_str(),
                           mParser.getCurrentLineNumber());
            mCommon.pFunction = CCopasiRootContainer::getUndefinedFunction();
          }

        // This must be deferred till the end since we need to check for consistency
        // of the parameters first (Bug 832)
        // mCommon.pReaction->setFunction(pFunction);
        break;

      case ListOfCallParameters:

        if (strcmp(pszName, "ListOfCallParameters"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfCallParameters", mParser.getCurrentLineNumber());

        if (mCommon.pFunction == CCopasiRootContainer::getUndefinedFunction())
          mParser.onStartElement(pszName, papszAttrs);

        /* If we do not have a etc element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new ListOfCallParametersElement(mParser, mCommon);

        /* Push the etc element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::KineticLawElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case KineticLaw:

        if (strcmp(pszName, "KineticLaw"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "KineticLaw", mParser.getCurrentLineNumber());

        mCommon.pReaction->setFunction(dynamic_cast< CFunction * >(mCommon.pFunction));

        {
          std::map< std::string, std::vector< std::string > >::const_iterator it
          = mCommon.SourceParameterKeys.begin();
          std::map< std::string, std::vector< std::string > >::const_iterator end
          = mCommon.SourceParameterKeys.end();

          for (; it != end; ++it)
            if (it->second.size() > 0)
              mCommon.pReaction->setParameterMappingVector(it->first, it->second);
        }
        mCommon.SourceParameterKeys.clear();

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case ListOfCallParameters:

        if (strcmp(pszName, "ListOfCallParameters"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfCallParameters", mParser.getCurrentLineNumber());

        mCurrentElement = KineticLaw;
        break;

      case UNKNOWN_ELEMENT:

        if (mCommon.pReaction->getFunction() == CCopasiRootContainer::getUndefinedFunction())
          mCurrentElement = KineticLaw;
        else
          mCurrentElement = mLastKnownElement;

        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ListOfCallParametersElement::ListOfCallParametersElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfCallParametersElement::~ListOfCallParametersElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfCallParametersElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfCallParameters:

        if (strcmp(pszName, "ListOfCallParameters"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfCallParameters", mParser.getCurrentLineNumber());

        break;

      case CallParameter:

        if (strcmp(pszName, "CallParameter"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "CallParameter", mParser.getCurrentLineNumber());

        /* If we do not have a CallParameter element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new CallParameterElement(mParser, mCommon);

        /* Push the CallParameter element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfCallParametersElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case ListOfCallParameters:

        if (strcmp(pszName, "ListOfCallParameters"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfCallParameters", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case CallParameter:

        if (strcmp(pszName, "CallParameter"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "CallParameter", mParser.getCurrentLineNumber());

        mCurrentElement = ListOfCallParameters;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::CallParameterElement::CallParameterElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::CallParameterElement::~CallParameterElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::CallParameterElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * FunctionParameter;

  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case CallParameter:

        if (strcmp(pszName, "CallParameter"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "CallParameter", mParser.getCurrentLineNumber());

        FunctionParameter =
          mParser.getAttributeValue("functionParameter", papszAttrs);

        mCommon.pFunctionVariable =
          dynamic_cast< CFunctionParameter* >(mCommon.KeyMap.get(FunctionParameter));

        if (!mCommon.pFunctionVariable)
          {
            fatalError();
          }

        break;

      case SourceParameter:

        if (strcmp(pszName, "SourceParameter"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "SourceParameter", mParser.getCurrentLineNumber());

        /* If we do not have a SourceParameter element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new SourceParameterElement(mParser, mCommon);

        /* Push the SourceParameter element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::CallParameterElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case CallParameter:

        if (strcmp(pszName, "CallParameter"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "CallParameter", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case SourceParameter:

        if (strcmp(pszName, "SourceParameter"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "SourceParameter", mParser.getCurrentLineNumber());

        mCurrentElement = CallParameter;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::SourceParameterElement::SourceParameterElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::SourceParameterElement::~SourceParameterElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::SourceParameterElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  const char * Reference;
  CCopasiObject * pObject;
  CCopasiParameter * pParameter;
  CModelEntity * pME;

  switch (mCurrentElement)
    {
      case SourceParameter:

        if (strcmp(pszName, "SourceParameter"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "SourceParameter", mParser.getCurrentLineNumber());

        Reference =
          mParser.getAttributeValue("reference", papszAttrs);

        pObject = mCommon.KeyMap.get(Reference);

        if ((pParameter = dynamic_cast< CCopasiParameter * >(pObject)))
          {
            // We need to assure that the parameter name for variables which are not
            // of type vector match.
            if (mCommon.pFunctionVariable->getType() < CFunctionParameter::VINT32)
              pParameter->setObjectName(mCommon.pFunctionVariable->getObjectName());

            mCommon.SourceParameterKeys[mCommon.pFunctionVariable->getObjectName()].push_back(pParameter->getKey());
          }
        else if ((pME = dynamic_cast<CModelEntity*>(pObject)))
          mCommon.SourceParameterKeys[mCommon.pFunctionVariable->getObjectName()].push_back(pME->getKey());
        else
          mCommon.SourceParameterKeys[mCommon.pFunctionVariable->getObjectName()].push_back(CFunctionParameterMap::pUnmappedObject->getKey());

        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::SourceParameterElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case SourceParameter:

        if (strcmp(pszName, "SourceParameter"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "SourceParameter", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::StateTemplateElement::StateTemplateElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::StateTemplateElement::~StateTemplateElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::StateTemplateElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case StateTemplate:

        if (strcmp(pszName, "StateTemplate"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "StateTemplate", mParser.getCurrentLineNumber());

        mCommon.StateVariableList.clear();
        break;

      case StateTemplateVariable:

        if (strcmp(pszName, "StateTemplateVariable"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "StateTemplateVariable", mParser.getCurrentLineNumber());

        /* If we do not have a StateTemplateVariable element handler we create one. */
        if (!mpCurrentHandler)
          mpCurrentHandler = new StateTemplateVariableElement(mParser, mCommon);

        /* Push the StateTemplateVariable element handler on the stack and call it. */
        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::StateTemplateElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case StateTemplate:

        if (strcmp(pszName, "StateTemplate"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "StateTemplate", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case StateTemplateVariable:

        if (strcmp(pszName, "StateTemplateVariable"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "StateTemplateVariable", mParser.getCurrentLineNumber());

        mCurrentElement = StateTemplate;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::StateTemplateVariableElement::StateTemplateVariableElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::StateTemplateVariableElement::~StateTemplateVariableElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::StateTemplateVariableElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * ObjectReference;
  CModelEntity * pME;

  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case StateTemplateVariable:

        if (strcmp(pszName, "StateTemplateVariable"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "StateTemplateVariable", mParser.getCurrentLineNumber());

        ObjectReference = mParser.getAttributeValue("objectReference",
                          papszAttrs);
        pME = dynamic_cast< CModelEntity * >(mCommon.KeyMap.get(ObjectReference));

        if (pME != NULL)
          mCommon.StateVariableList.push_back(pME);
        else
          fatalError();

        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::StateTemplateVariableElement::end(const XML_Char *pszName)
{
  switch (mCurrentElement)
    {
      case StateTemplateVariable:

        if (strcmp(pszName, "StateTemplateVariable"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "StateTemplateVariable", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::InitialStateElement::InitialStateElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::InitialStateElement::~InitialStateElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::InitialStateElement::start(const XML_Char *pszName,
    const XML_Char **papszAttrs)
{
  const char * Type;

  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case InitialState:

        if (strcmp(pszName, "InitialState"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "InitialState", mParser.getCurrentLineNumber());

        Type = mParser.getAttributeValue("type", papszAttrs, "initialState");

        if (strcmp(Type, "initialState")) fatalError();

        mParser.enableCharacterDataHandler();
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::InitialStateElement::end(const XML_Char *pszName)
{
  std::istringstream Values;
  std::string StringValue;
  std::vector< CModelEntity * >::iterator it;
  std::vector< CModelEntity * >::iterator end;
  double Value;

  const CStateTemplate & Template = mCommon.pModel->getStateTemplate();
  CState IState = mCommon.pModel->getInitialState();
  C_FLOAT64 * pValues = IState.beginIndependent() - 1;
  size_t Index;

  switch (mCurrentElement)
    {
      case InitialState:

        if (strcmp(pszName, "InitialState"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "InitialState", mParser.getCurrentLineNumber());

        Values.str(mParser.getCharacterData("\x0a\x0d\t ", " "));

        it = mCommon.StateVariableList.begin();
        end = mCommon.StateVariableList.end();

        for (Values >> StringValue; it != end; ++it, Values >> StringValue)
          {
            if (Values.fail()) break;

            Value = CCopasiXMLInterface::DBL(StringValue.c_str());

            Index = Template.getIndex(*it);

            if (Index != C_INVALID_INDEX)
              {
                pValues[Index] = Value;
                continue;
              }

            fatalError();
          }

        if (it != end || !Values.fail() || !Values.eof())
          {
            CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 17, mParser.getCurrentLineNumber());
          }

        mCommon.pModel->setInitialState(IState);

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;

        /* Tell the parent element we are done. */
        mParser.onEndElement(pszName);
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ListOfPlotItemsElement::ListOfPlotItemsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfPlotItemsElement::~ListOfPlotItemsElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfPlotItemsElement::start(const XML_Char * pszName,
    const XML_Char ** papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfPlotItems:

        if (strcmp(pszName, "ListOfPlotItems"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfPlotItems", mParser.getCurrentLineNumber());

        break;

      case PlotItem:

        if (strcmp(pszName, "PlotItem"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "PlotItem", mParser.getCurrentLineNumber());

        // If we do not have a plot specification element handler, we create one
        if (!mpCurrentHandler)
          {
            mpCurrentHandler = new PlotItemElement(mParser, mCommon);
          }

        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfPlotItemsElement::end(const XML_Char * pszName)
{
  switch (mCurrentElement)
    {
      case ListOfPlotItems:

        if (strcmp(pszName, "ListOfPlotItems"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfPlotItems", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;
        mParser.onEndElement(pszName);
        break;

      case PlotItem:

        if (strcmp(pszName, "PlotItem"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "PlotItem", mParser.getCurrentLineNumber());

        mCommon.pCurrentPlotItem = mCommon.pCurrentPlot;
        mCurrentElement = ListOfPlotItems;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ListOfChannelsElement::ListOfChannelsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfChannelsElement::~ListOfChannelsElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfChannelsElement::start(const XML_Char * pszName,
    const XML_Char ** papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfChannels:

        if (strcmp(pszName, "ListOfChannels"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfChannels", mParser.getCurrentLineNumber());

        break;

      case ChannelSpec:

        if (strcmp(pszName, "ChannelSpec"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ChannelSpec", mParser.getCurrentLineNumber());

        if (!mpCurrentHandler)
          {
            mpCurrentHandler = new ChannelSpecElement(mParser, mCommon);
          }

        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfChannelsElement::end(const XML_Char * pszName)
{
  switch (mCurrentElement)
    {
      case ListOfChannels:

        if (strcmp(pszName, "ListOfChannels"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfChannels", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;
        mParser.onEndElement(pszName);
        break;

      case ChannelSpec:

        if (strcmp(pszName, "ChannelSpec"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ChannelSpec", mParser.getCurrentLineNumber());

        mCommon.pCurrentPlotItem->getChannels().push_back(*(mCommon.pCurrentChannelSpec));

        delete mCommon.pCurrentChannelSpec;
        mCommon.pCurrentChannelSpec = NULL;
        mCurrentElement = ListOfChannels;
        break;

      case UNKNOWN_ELEMENT:
        mCurrentElement = mLastKnownElement;
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                       pszName, "???", mParser.getCurrentLineNumber());
        break;
    }

  return;
}

CCopasiXMLParser::ListOfPlotsElement::ListOfPlotsElement(CCopasiXMLParser & parser,
    SCopasiXMLParserCommon & common):
  CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >(parser, common)
{}

CCopasiXMLParser::ListOfPlotsElement::~ListOfPlotsElement()
{
  deleteCurrentHandler();
}

void CCopasiXMLParser::ListOfPlotsElement::start(const XML_Char * pszName,
    const XML_Char ** papszAttrs)
{
  mCurrentElement++; /* We should always be on the next element */

  switch (mCurrentElement)
    {
      case ListOfPlots:

        if (strcmp(pszName, "ListOfPlots"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "ListOfPlots", mParser.getCurrentLineNumber());

        if (!mCommon.pPlotList)
          {
            mCommon.pPlotList = new COutputDefinitionVector;
          }

        break;

      case PlotSpecification:

        if (strcmp(pszName, "PlotSpecification"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 10,
                         pszName, "PlotSpecification", mParser.getCurrentLineNumber());

        // If we do not have a plot specification element handler, we create one
        if (!mpCurrentHandler)
          {
            mpCurrentHandler = new PlotSpecificationElement(mParser, mCommon);
          }

        mParser.pushElementHandler(mpCurrentHandler);
        mpCurrentHandler->start(pszName, papszAttrs);
        break;

      default:
        mLastKnownElement = mCurrentElement - 1;
        mCurrentElement = UNKNOWN_ELEMENT;
        mParser.pushElementHandler(&mParser.mUnknownElement);
        mParser.onStartElement(pszName, papszAttrs);
        break;
    }

  return;
}

void CCopasiXMLParser::ListOfPlotsElement::end(const XML_Char * pszName)
{
  switch (mCurrentElement)
    {
      case ListOfPlots:

        if (strcmp(pszName, "ListOfPlots"))
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCXML + 11,
                         pszName, "ListOfPlots", mParser.getCurrentLineNumber());

        mParser.popElementHandler();
        mCurrentElement = START_ELEMENT;
        mParser.onEndElement(pszName);
        break;
&#