iphreeqc/SAXPhreeqc.cxx

// SAXPhreeqc.cpp
#ifdef _DEBUG
#pragma warning(disable : 4786)   // disable truncation warning (Only used by debugger)
#endif

#include <float.h>                         // DBL_DIG
#include <stdio.h>                         // sprintf
#include <wctype.h>                        // iswspace

#include <cassert>                         // assert
//#include <strstream>                       // std::ostrstream
#include <sstream>
#include <iostream>                        // std::cerr
#ifdef SKIP
#endif
#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif


#include <xercesc/framework/StdInInputSource.hpp>
#include <xercesc/framework/MemoryManager.hpp>
#include <xercesc/framework/XMLGrammarPool.hpp>
#include <xercesc/internal/XMLGrammarPoolImpl.hpp>
#include <xercesc/internal/MemoryManagerImpl.hpp>
#include <xercesc/validators/common/Grammar.hpp>

//#include <xercesc/parsers/SAXParser.hpp>           // SAXParser
#include <xercesc/sax/AttributeList.hpp>           // AttributeList
#include <xercesc/util/XMLUniDefs.hpp>             // Unicode definitions
#include <xercesc/framework/MemBufInputSource.hpp> // MemBufInputSource
#include <xercesc/framework/MemoryManager.hpp>
#include <xercesc/internal/MemoryManagerImpl.hpp>
#include <xercesc/util/PlatformUtils.hpp>          // XMLPlatformUtils::getCurrentMillis
#include <xercesc/util/XMLUni.hpp>

#include <xercesc/sax2/SAX2XMLReader.hpp>
#include <xercesc/sax2/XMLReaderFactory.hpp>

#include "SAXPhreeqc.h"                    // SAX_ functions
#include "SaxPhreeqcHandlers.h"            // SaxPhreeqcHandlers

//XERCES_CPP_NAMESPACE_USE
#define xns XERCES_CPP_NAMESPACE

///static char buffer[300000];
///static std::ostrstream s_oss(buffer, 300000);        // must never go out of scope
static std::ostringstream s_oss;        // must never go out of scope
static bool s_bSysIsOpen = false;    // must never go out of scope

#include <math.h>
// extern routines
  #include "phqalloc.h"
  #include "global.h"
#include "phrqproto.h"
#include "output.h"
#ifdef SKIP
  int conc_init(struct conc *conc_ptr);
  void *free_check_null(void *ptr);
  int pe_data_store (struct pe_data **pe, const char *token);
  struct phase *phase_bsearch (char *ptr, int *j, int print);
  struct solution *solution_alloc(void);
  struct solution *solution_bsearch(int k, int *n, int print);
  int solution_free (struct solution *solution_ptr);
  void space (void **ptr, int i, int *max, int struct_size);
  char * string_duplicate (const char *token);
  char *string_hsave (const char *str);
  int error_msg (const char *err_str, const int stop);
  struct master *master_bsearch (const char *ptr);
  void malloc_error(void);
#endif
//}


class Initializer
{
public:
  Initializer(){ 
#if defined(_DEBUG) 
	int tmpDbgFlag;

	/*
	* Set the debug-heap flag to keep freed blocks in the
	* heap's linked list - This will allow us to catch any
	* inadvertent use of freed memory
	*/
	tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
	//tmpDbgFlag |= _CRTDBG_DELAY_FREE_MEM_DF;
	tmpDbgFlag |= _CRTDBG_LEAK_CHECK_DF;
	//tmpDbgFlag |= _CRTDBG_CHECK_ALWAYS_DF;
	_CrtSetDbgFlag(tmpDbgFlag);
#endif 

	xns::XMLPlatformUtils::Initialize();
  }
};

static Initializer sInit;  // initialize xerces once
static SaxPhreeqcHandlers s_handler; // one and only instance

void SAX_StartSystem()
{

  assert(!s_bSysIsOpen);     // system already open and has not been closed

  // init stream
  //s_oss.freeze(false);
  s_oss.seekp(0);
  
  // write stream
  // s_oss << "<system>";
  s_oss << "<?xml version=\"1.0\" ?>";
  s_oss << "<phast_state nx=\"2\">";
  s_oss << " <system system_number=\"1\">";
  s_bSysIsOpen = true;

}

char * stringify_null(char * string) {
	if (string == NULL) return(string_hsave(""));
	return(string);
}
int SAX_AddSolution(struct solution* solution_ptr)
{
	//const char    ERR_MESSAGE[] = "Packing solution message: %s, element not found\n";
  int i, newd;  
  assert(s_bSysIsOpen);      // must call SAX_StartSystem first
	s_oss.precision(DBL_DIG - 1);
	// Solution element and attributes
    newd = solution_ptr->new_def;
	s_oss << "  <solution " << std::endl;
	s_oss << "   soln_new_def=\"" << solution_ptr->new_def << "\"" << std::endl;
	s_oss << "   soln_n_user=\"" << solution_ptr->n_user << "\" " << std::endl;
	s_oss << "   soln_n_user_end=\"" << solution_ptr->n_user_end << "\"" << std::endl;
	s_oss << "   soln_description=\"" << solution_ptr->description << "\"" << std::endl;
	s_oss << "   soln_tc=\"" << solution_ptr->tc << "\"" << std::endl;
	s_oss << "   soln_ph=\"" << solution_ptr->ph << "\"" << std::endl;
	s_oss << "   soln_solution_pe=\"" << solution_ptr->solution_pe << "\"" << std::endl;
	s_oss << "   soln_mu=\"" << solution_ptr->mu << "\"" << std::endl;
	s_oss << "   soln_ah2o=\""	 << solution_ptr->ah2o << "\"" << std::endl;
	s_oss << "   soln_density=\"" << solution_ptr->density << "\"" << std::endl;
	s_oss << "   soln_total_h=\"" << solution_ptr->total_h << "\"" << std::endl;
	s_oss << "   soln_total_o=\"" << solution_ptr->total_o << "\"" << std::endl;
	s_oss << "   soln_cb=\"" << solution_ptr->cb << "\"" << std::endl;
	s_oss << "   soln_mass_water=\"" << solution_ptr->mass_water << "\"" << std::endl;
	s_oss << "   soln_total_alkalinity=\"" << solution_ptr->total_alkalinity << "\"" << std::endl;
	//s_oss << "   soln_total_co2=\"" << solution_ptr->total_co2 << "\"" << std::endl;
	s_oss << "   soln_units=\"" << solution_ptr->units << "\"" << std::endl;
	s_oss << "   soln_default_pe=\"" << solution_ptr->default_pe << "\"" << std::endl;
	s_oss << "   soln_count_master_activity=\"" << solution_ptr->count_master_activity << "\"" << std::endl;
	s_oss << "   soln_count_isotopes=\"" << solution_ptr->count_isotopes << "\"" << std::endl;
	s_oss << "   soln_count_species_gamma=\"" << solution_ptr->count_species_gamma << "\">" << std::endl;
	// end of solution attributes
	// pe structures
	for (i=0; solution_ptr->pe[i].name != NULL; i++) {
		s_oss << "   <soln_pe soln_pe_name=\"" << solution_ptr->pe[i].name << "\"/>"<< std::endl; 
	}
	// soln_total conc structures
	for (i=0; solution_ptr->totals[i].description != NULL; i++) {
		struct conc *c = &(solution_ptr->totals[i]);
		s_oss << "   <soln_total " << std::endl;
		s_oss << "    conc_desc=\"" << c->description << "\"" << std::endl;
		s_oss << "    conc_moles=\"" << c->moles << "\"" << std::endl;
		if (newd == TRUE) {
			s_oss << "    conc_input_conc=\"" << c->input_conc << "\"" << std::endl;
			if (c->units != NULL) s_oss << "        conc_units=\"" << c->units << "\"" << std::endl;
			if (c->equation_name != NULL) {
				s_oss << "    conc_equation_name=\"" << stringify_null(c->equation_name) << "\"" << std::endl;
				s_oss << "    conc_phase_si=\"" << c->phase_si << "\"" << std::endl;
			}
			if (c->as != NULL) s_oss << "        conc_as=\"" << stringify_null(c->as) << "\"" << std::endl;
			s_oss << "    conc_gfw=\"" << c->gfw << "\"" << std::endl;
		}
		s_oss << "    conc_n_pe=\"" << c->n_pe << "\"" << std::endl;
		s_oss << "   />" << std::endl; 
	}
	// master_activity, master_activity structure
	
	for (i=0; i < solution_ptr->count_master_activity; i++) {
		s_oss << "   <soln_m_a m_a_desc=\"" << stringify_null(solution_ptr->master_activity[i].description) << "\" m_a_la=\"" << solution_ptr->master_activity[i].la << "\"/>" << std::endl;
	}
	/*
	if (solution_ptr->count_master_activity > 0) {
		s_oss << "      <soln_m_a m_a_list=\"" << std::endl;
		for (i=0; i < solution_ptr->count_master_activity; i++) {
			if (solution_ptr->master_activity[i].description != NULL) {
				s_oss << stringify_null(solution_ptr->master_activity[i].description) << " ";
				s_oss << solution_ptr->master_activity[i].la << std::endl;
			} else {
				s_oss << "null 0.0" << std::endl;
			}
		}
		s_oss << "\"/>" << std::endl;
	}
    */
	// species_gamma, mater_activity structure
	for (i=0; i < solution_ptr->count_species_gamma; i++) {
		s_oss << "   <soln_s_g m_a_desc=\"" << stringify_null(solution_ptr->species_gamma[i].description) << "\" m_a_la=\"" << solution_ptr->species_gamma[i].la << "\"/>" << std::endl;
	}
	// isotopes, isotope structure
	for (i=0; solution_ptr->count_isotopes; i++) {
		s_oss << "   <soln_isotope " << std::endl;
		s_oss << "    iso_isotope_number=\"" << solution_ptr->isotopes[i].isotope_number << "\"" << std::endl;
		s_oss << "    iso_elt_name=\"" << solution_ptr->isotopes[i].elt_name << "\"" << std::endl;
		s_oss << "    iso_isotope_name=\"" << solution_ptr->isotopes[i].isotope_name << "\"" << std::endl;
		s_oss << "    iso_total=\"" << solution_ptr->isotopes[i].total << "\"" << std::endl;
		s_oss << "    iso_ratio=\"" << solution_ptr->isotopes[i].ratio << "\"" << std::endl;
		s_oss << "    iso_ratio_uncertainty=\"" << solution_ptr->isotopes[i].ratio_uncertainty << "\"" << std::endl;
		s_oss << "    iso_coef=\"" << solution_ptr->isotopes[i].coef << "\"" << std::endl;
	}
	// End of solution
	s_oss << "  </solution>" << std::endl;

  return(OK);
}

void SAX_EndSystem()
{
  assert(s_bSysIsOpen);      // must call SAX_StartSystem first

  s_oss << " </system>" << std::endl;
  s_oss << "</phast_state>" << std::endl; 
  s_oss << '\0';
  
  s_bSysIsOpen = false;
  //delete[] s_handler;
  return;
}

int SAX_GetXMLLength()
{
  assert(!s_bSysIsOpen);      // must call SAX_EndSystem first
  //return s_oss.pcount();
  return s_oss.str().size();
}

const char* SAX_GetXMLStr()
{
  assert(!s_bSysIsOpen);      // must call SAX_EndSystem first
  return s_oss.str().c_str();
}

void SAX_cleanup()
{
   //delete s_handler;
   //s_oss.freeze(false);
} 

// utility routines

int XMLCh2Int(const XMLCh* const attValue) {
		char *string = xns::XMLString::transcode(attValue);
	    int i = strtol(string, NULL, 10);
		xns::XMLString::release(&string);
		return i;
		//return (xns::XMLString::parseInt(attValue));
}
double XMLCh2Double(const XMLCh* const attValue) {
		char *string = xns::XMLString::transcode(attValue);
	    double d = strtod(string, NULL);
		xns::XMLString::release(&string);
		return d;
}
char * XMLCh2String(const XMLCh* const attValue) {
		char *string = xns::XMLString::transcode(attValue);
		char *s = string_duplicate(string);
		xns::XMLString::release(&string);
		return s;
}
char * XMLCh_hsave(const XMLCh* const attValue, bool allow_null) {
		char *string = xns::XMLString::transcode(attValue);
	    char *s = string_hsave(string);
		if (allow_null && strlen(s) == 0) s = NULL;
		xns::XMLString::release(&string);
		return s;
}


int SAX_UnpackSolutions(void* pvBuffer, int buf_size)
{
  //  Create MemBufferInputSource from the buffer containing the XML
  //  statements.
	xns::MemBufInputSource memBufIS((const XMLByte*)pvBuffer, buf_size, "solution_id", false);
	fprintf(stderr,"%s", (char *) pvBuffer);
	return 0;
  //
  //  Create a SAX2 parser object.
  //
	xns::SAX2XMLReader * parser = xns::XMLReaderFactory::createXMLReader();
	parser->setFeature(xns::XMLUni::fgXercesSchemaFullChecking, false);
	parser->setFeature(xns::XMLUni::fgSAX2CoreNameSpaces, false);
	parser->setFeature(xns::XMLUni::fgXercesSchema, false);
 	parser->setFeature(xns::XMLUni::fgXercesIdentityConstraintChecking, false); 
  //
  //  Create the handler object and install it as the document and error
  //  handler for the parser. Then parse the MemBufferInputSource and 
  //  catch any exceptions that propogate out
  //
  try
    {
      unsigned long duration = 0;
      parser->setContentHandler(&s_handler);
      parser->setErrorHandler(&s_handler);      
      int t = 0;
      for (; t < 1000; ++t)
	{
		const unsigned long startMillis = xns::XMLPlatformUtils::getCurrentMillis();
		parser->parse(memBufIS);
		const unsigned long endMillis = xns::XMLPlatformUtils::getCurrentMillis();
		duration += endMillis - startMillis;
	}
      std::cerr << "\nSaxParse time = " << duration << " millis\n";
    }
  catch (const xns::SAXException& toCatch)
    {
      char* psz = xns::XMLString::transcode(toCatch.getMessage());
      input_error++;
      sprintf(error_string, "SAX_UnpackSolutions: %s\n", psz);
      error_msg(error_string, CONTINUE);
	  xns::XMLString::release(&psz);
      return ERROR;
    }
  catch (const xns::XMLException& toCatch)
    {
      char* psz = xns::XMLString::transcode(toCatch.getMessage());
      input_error++;
      sprintf(error_string, "SAX_UnpackSolutions: %s\n", psz);
      error_msg(error_string, CONTINUE);
	  xns::XMLString::release(&psz);
      return ERROR;
    }
  catch (...)
    {
      input_error++;
      sprintf(error_string,"SAX_UnpackSolutions: %s\n", "Unknown error occured.");
      error_msg(error_string, CONTINUE);
      return ERROR;
    }

  return(OK);
}


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

// element names

SaxPhreeqcHandlers::SaxPhreeqcHandlers()
  : eltType(typeNULL), attType(attNULL), totals(), acts(), solution_ptr(NULL)
{
	int i;

	int count_elementInfo, count_attributeInfo;
	struct mapElementInfo {char *key; enum elementType type;};
	struct mapAttributeInfo {enum attributeType type; char *key;};
	struct mapElementInfo elementInfo[] = {
		{"phast_state", typePHAST_STATE},
		{"system", typeSYSTEM},
		{"solution", typeSOLUTION},
		{"soln_pe", typeSOLN_PE},
		{"soln_total", typeSOLN_TOTAL},
		{"soln_m_a", typeSOLN_MASTER_ACTIVITY},
		{"soln_isotope", typeSOLN_ISOTOPE},
		{"soln_s_g", typeSOLN_SPECIES_GAMMA}
	};
	count_elementInfo = sizeof(elementInfo)/sizeof(struct mapElementInfo);
	struct mapAttributeInfo	attributeInfo[] = {	
		// Solution structure
	  {attSOLN_new_def, "soln_new_def"},
	  {attSOLN_n_user, "soln_n_user"},
	  {attSOLN_n_user_end, "soln_n_user_end"},
	  {attSOLN_description, "soln_description"},
	  {attSOLN_tc, "soln_tc"},
	  {attSOLN_ph, "soln_ph"},
	  {attSOLN_solution_pe, "soln_solution_pe"},
	  {attSOLN_mu, "soln_mu"},
	  {attSOLN_ah2o, "soln_ah2o"},
	  {attSOLN_density, "soln_density"},
	  {attSOLN_total_h, "soln_total_h"},
	  {attSOLN_total_o, "soln_total_o"},
	  {attSOLN_cb, "soln_cb"},
	  {attSOLN_mass_water, "soln_mass_water"},
	  {attSOLN_total_alkalinity, "soln_total_alkalinity"},
	  {attSOLN_total_co2, "soln_total_co2"},
	  {attSOLN_units, "soln_units"},
	  {attSOLN_default_pe, "soln_default_pe"},
	  {attSOLN_count_master_activity, "soln_count_master_activity"},
	  {attSOLN_count_isotopes, "soln_count_isotopes"},
	  {attSOLN_count_species_gamma, "soln_count_species_gamma"},
	  {attSOLN_PE_name, "soln_pe_name"},
		// master_activity structure
	  {attM_A_description, "m_a_desc"},
	  {attM_A_la, "m_a_la"},
	  {attM_A_list, "m_a_list"},
		// isotope structure
	  {attISO_isotope_number, "iso_isotope_number"},
	  {attISO_elt_name, "iso_elt_name"},
	  {attISO_isotope_name, "iso_isotope_name"},
	  {attISO_total, "iso_total"},
	  {attISO_ratio, "iso_ratio"},
	  {attISO_ratio_uncertainty, "iso_ratio_uncertainty"},
	  {attISO_x_ratio_uncertainty, "iso_x_ratio_uncertainty"},
	  {attISO_coef, "iso_coef"},
		// conc structure
	  {attCONC_description, "conc_desc"},
	  {attCONC_moles, "conc_moles"},
	  {attCONC_input_conc, "conc_input_conc"},
	  {attCONC_units, "conc_units"},
	  {attCONC_equation_name, "conc_equation_name"},
	  {attCONC_phase_si, "conc_phase_si"},
	  {attCONC_n_pe, "conc_n_pe"},
	  {attCONC_as, "conc_as"},
	  {attCONC_gfw, "conc_gfw"},

	};

	count_attributeInfo = sizeof(attributeInfo)/sizeof(struct mapAttributeInfo);
	for (i = 0; i < count_elementInfo; i++) {
		// memory freed in destructor
		this->mapXMLCh2Type[xns::XMLString::transcode(elementInfo[i].key)] = elementInfo[i].type;
	}
	for (i = 0; i < count_attributeInfo; i++) {
		// memory freed in destructor
		this->mapXMLCh2AttType[xns::XMLString::transcode(attributeInfo[i].key)] = attributeInfo[i].type;
	}

	this->totals.reserve(50);
	this->acts.reserve(50);
}

SaxPhreeqcHandlers::~SaxPhreeqcHandlers()
{
	std::map<const XMLCh*, elementType, XMLCH_LESS>::iterator it = this->mapXMLCh2Type.begin();
	for (; it != this->mapXMLCh2Type.end(); ++it)
	{
		XMLCh* p = (XMLCh*)it->first;
		xns::XMLString::release(&p);
	}
	this->mapXMLCh2Type.clear();
	std::map<const XMLCh*, attributeType, XMLCH_LESS>::iterator ita = this->mapXMLCh2AttType.begin();
	for (; ita != this->mapXMLCh2AttType.end(); ++ita)
	{
		XMLCh* p = (XMLCh*)ita->first;
		xns::XMLString::release(&p);
	}
	this->mapXMLCh2AttType.clear();

}

// -----------------------------------------------------------------------
//  Implementations of the SAX DocumentHandler interface
// -----------------------------------------------------------------------

void SaxPhreeqcHandlers::endDocument()
{
}

void SaxPhreeqcHandlers::endElement(const XMLCh* const uri, const XMLCh* const name, const XMLCh* const qname)
{
  switch (this->mapXMLCh2Type[name])
    {
	case typeSOLUTION:
		// solution is finished now copy into solutions array
		{
			int n;
			// copy vector of conc's to solution
			this->solution_ptr->totals = (struct conc*) PHRQ_realloc(this->solution_ptr->totals, (size_t) (this->totals.size() + 1) * sizeof(struct conc));
			std::copy(this->totals.begin(), this->totals.end(), this->solution_ptr->totals);
			this->solution_ptr->totals[this->totals.size()].description=NULL;
			this->totals.clear();
			assert(this->totals.size() == 0);

			// copy vector of master_activities's to solution
			this->solution_ptr->master_activity = (struct master_activity *) free_check_null(this->solution_ptr->master_activity);
			if (this->acts.size() > 0) {
				this->solution_ptr->master_activity = (struct master_activity *) PHRQ_realloc(this->solution_ptr->master_activity, (size_t) (this->acts.size()) * sizeof(struct master_activity));
				std::copy(this->acts.begin(), this->acts.end(), this->solution_ptr->master_activity);
			}
			this->solution_ptr->count_master_activity = this->acts.size();
			this->acts.clear();
			assert(this->acts.size() == 0);

			// copy vector of s_gamma's to solution
			this->solution_ptr->species_gamma = (struct master_activity *) free_check_null(this->solution_ptr->species_gamma);
			if (this->s_gammas.size() > 0) {
				this->solution_ptr->species_gamma = (struct master_activity *) PHRQ_realloc(this->solution_ptr->species_gamma, (size_t) (this->s_gammas.size()) * sizeof(struct master_activity));
				std::copy(this->s_gammas.begin(), this->s_gammas.end(), this->solution_ptr->species_gamma);
			}
			this->solution_ptr->count_species_gamma = this->s_gammas.size();
			this->s_gammas.clear();
			assert(this->s_gammas.size() == 0);

			// copy vector of isotopes's to solution
			this->solution_ptr->isotopes = (struct isotope *) free_check_null(this->solution_ptr->isotopes);
			if (this->isotopes.size() > 0) {
				this->solution_ptr->isotopes = (struct isotope *) PHRQ_realloc(this->solution_ptr->isotopes, (size_t) (this->isotopes.size()) * sizeof(struct isotope));
				std::copy(this->isotopes.begin(), this->isotopes.end(), this->solution_ptr->isotopes);
			}
			this->solution_ptr->count_isotopes = this->isotopes.size();
			this->isotopes.clear();
			assert(this->isotopes.size() == 0);


			// store solution for now
			if (solution_bsearch(this->solution_ptr->n_user, &n, FALSE) != NULL) {
				solution_free(solution[n]);
				solution[n] = this->solution_ptr;
			} else {
				n = count_solution++;
				if (count_solution >= max_solution)
				{
					space ((void **) &(solution), count_solution, &max_solution, sizeof (struct solution *) );
				}
				solution[n] = this->solution_ptr;
			}
			this->solution_ptr = NULL;
		}
		break;
    default:
      break;
    }
}

void SaxPhreeqcHandlers::characters(const XMLCh* const chars, const unsigned int length)
{
  // skip whitespace

	//XMLCh* pChar = (XMLCh*)chars;
	//while(pChar && iswspace(*pChar)) ++pChar;
	//if (*pChar)
	// {
/*
    switch(this->eltType)
	{
		case typeSOLN_MASTER_ACTIVITY:
			//xns::BaseRefVectorOf<XMLCh> *arg = xns::XMLString::tokenizeString(chars);
			for ( i = 0; i < arg->size() - 1; i+=2 ) {
				struct master_activity *ma = new master_activity();
				ma->description = XMLCh_hsave( arg->elementAt(i), true);
				ma->la = XMLCh2Double( arg->elementAt(i + 1));
				this->acts.push_back(*ma);
			}
			//struct master_activity *ma = new master_activity();
			//ma->description = NULL;
			//this->acts.push_back(*ma);
			break;
	}
	*/

}

void SaxPhreeqcHandlers::ignorableWhitespace(const XMLCh* const chars, const unsigned int length)
{
}

void SaxPhreeqcHandlers::processingInstruction(const XMLCh* const target, const XMLCh* const data)
{
}

void SaxPhreeqcHandlers::startDocument()
{
}

void SaxPhreeqcHandlers::startElement(const XMLCh* const uri, const XMLCh* const name, const XMLCh* const qname, const xns::Attributes& attributes)
{
	//const char ERR_MSG[] = "Unpacking solution message: %s, element not found\n";
  char *string;

  int i;

  string = xns::XMLString::transcode(name);
  this->eltType = this->mapXMLCh2Type[name];
  xns::XMLString::release(&string);
  switch (this->eltType)
    {
    case typePHAST_STATE:
		XMLCh *x;
		x = xns::XMLString::transcode("nx");
		i = XMLCh2Int(attributes.getValue(x));
		xns::XMLString::release(&x);
		break;
    case typeSOLUTION:
      assert(this->solution_ptr == NULL);
      assert(this->totals.size() == 0);
      assert(this->acts.size() == 0);
      
      // allocate space for solution
      this->solution_ptr = solution_alloc();
      
      // process attributes for solution
	  processSolutionAttributes(attributes);
	  break;
    case typeSOLN_PE:
		assert(this->solution_ptr->pe != NULL);
		// store pe, no need to clean up at end of solution
		if ((attributes.getLength() >= 1) && (this->mapXMLCh2AttType[attributes.getLocalName(0)] == attSOLN_PE_name)){
			string = xns::XMLString::transcode(attributes.getValue((unsigned int) 0));
			pe_data_store(&(this->solution_ptr->pe), string);
			xns::XMLString::release(&string);
		} else {
			++input_error;
			sprintf(error_string, "No attribute data for SOLN_PE.\n");
			error_msg(error_string, CONTINUE);
		}
		break;
    case typeSOLN_TOTAL:
		{
			// store in c, push_back on totals
			// need to copy and clean up at end of </solution>
			struct conc c;
			processSolutionTotalAttributes(attributes, &c);
			this->totals.push_back(c);
		}
		break;  
    case typeSOLN_MASTER_ACTIVITY:
		{
			// store in ma, push_back on acts
			// need to copy and clean up at end of </solution>
			struct master_activity ma;
			processMasterActivityAttributes(attributes, &ma);
			this->acts.push_back(ma);
			//processMasterActivityAttributes(attributes, &this->acts);
		}
		break;
    case typeSOLN_SPECIES_GAMMA:
		{
			// store in ma, push_back on s_gammas
			// need to copy and clean up at end of </solution>
			struct master_activity ma;
			processMasterActivityAttributes(attributes, &ma);
			this->s_gammas.push_back(ma);
		}
		break;
    case typeSOLN_ISOTOPE:
		{
			// store in iso, push_back on isotopes
			// need to copy and clean up at end of </solution>
			struct isotope iso;
			processIsotopeAttributes(attributes, &iso);
			this->isotopes.push_back(iso);
		}
		break;  

    default:
      break;
    }
}
int SaxPhreeqcHandlers::processSolutionAttributes(const xns::Attributes& attributes)
{
	const char ERR_MSG[] = "Unpacking solution attributes: %s, attribute not found\n";	
	unsigned int i;
	char *string;
	attributeType attType;
	assert(this->eltType == typeSOLUTION);
	assert(this->solution_ptr != NULL);

	// Get attribute name, map to attribute type, process

	for (i = 0; i < attributes.getLength(); i++) {
		attType = this->mapXMLCh2AttType[attributes.getLocalName(i)];
		switch (attType) {
		case attSOLN_new_def:
			this->solution_ptr->new_def = XMLCh2Int(attributes.getValue(i));
			break;
		case attSOLN_n_user:
			this->solution_ptr->n_user = XMLCh2Int(attributes.getValue(i));
			break;
		case attSOLN_n_user_end:
			this->solution_ptr->n_user_end = XMLCh2Int(attributes.getValue(i));
			break;
		case attSOLN_description:
			this->solution_ptr->description = XMLCh2String(attributes.getValue(i));
			break;
		case attSOLN_tc:
			this->solution_ptr->tc = XMLCh2Double(attributes.getValue(i));
			break;
		case attSOLN_ph:
			this->solution_ptr->ph = XMLCh2Double(attributes.getValue(i));
			break;
		case attSOLN_solution_pe:
			this->solution_ptr->solution_pe = XMLCh2Double(attributes.getValue(i));
			break;
		case attSOLN_mu:
			this->solution_ptr->mu = XMLCh2Double(attributes.getValue(i));
			break;
		case attSOLN_ah2o:
			this->solution_ptr->ah2o = XMLCh2Double(attributes.getValue(i));
			break;
		case attSOLN_density:
			this->solution_ptr->density = XMLCh2Double(attributes.getValue(i));
			break;
		case attSOLN_total_h:
			this->solution_ptr->total_h = XMLCh2Double(attributes.getValue(i));
			break;
		case attSOLN_total_o:
			this->solution_ptr->total_o = XMLCh2Double(attributes.getValue(i));
			break;
		case attSOLN_cb:
			this->solution_ptr->cb = XMLCh2Double(attributes.getValue(i));
			break;
		case attSOLN_mass_water:
			this->solution_ptr->mass_water = XMLCh2Double(attributes.getValue(i));
			break;
		case attSOLN_total_alkalinity:
			this->solution_ptr->total_alkalinity = XMLCh2Double(attributes.getValue(i));
			break;
			//case attSOLN_total_co2:
			//this->solution_ptr->total_co2 = XMLCh2Double(attributes.getValue(i));
			//break;
		case attSOLN_units:
			this->solution_ptr->units = XMLCh_hsave(attributes.getValue(i), TRUE);
			break;
		case attSOLN_default_pe:
			this->solution_ptr->default_pe = XMLCh2Int(attributes.getValue(i));
			break;
		case attSOLN_count_master_activity:
			this->solution_ptr->count_master_activity = XMLCh2Int(attributes.getValue(i));
			break;
		case attSOLN_count_isotopes:
			this->solution_ptr->count_isotopes = XMLCh2Int(attributes.getValue(i));
			break;
		case attSOLN_count_species_gamma:
			this->solution_ptr->count_species_gamma = XMLCh2Int(attributes.getValue(i));
			break;
		default:
			++input_error;
			string = xns::XMLString::transcode(attributes.getLocalName(i));
			sprintf(error_string, ERR_MSG, string);
			error_msg(error_string, CONTINUE);
			xns::XMLString::release(&string);
			break;
		}
	}
	return 0;
}
int SaxPhreeqcHandlers::processSolutionTotalAttributes(const xns::Attributes& attributes, struct conc *c)
{
	const char ERR_MSG[] = "Unpacking solution totals attributes: %s, attribute not found\n";	
	unsigned int i;
	char *string;
	conc_init(c);
	attributeType attType;
	assert(this->eltType == typeSOLN_TOTAL);


	// Get attribute name, map to attribute type, process

	for (i = 0; i < attributes.getLength(); i++) {
		attType = this->mapXMLCh2AttType[attributes.getLocalName(i)];
		switch (attType) {
		case attCONC_description:
			c->description = XMLCh_hsave(attributes.getValue(i), TRUE);
			break;
		case attCONC_moles:
			c->moles = XMLCh2Double(attributes.getValue(i));
			break;
		case attCONC_input_conc:
			c->input_conc = XMLCh2Double(attributes.getValue(i));
			break;		
		case attCONC_units:
			c->units = XMLCh_hsave(attributes.getValue(i), TRUE);
			break;	
		case attCONC_equation_name:
			c->equation_name = XMLCh_hsave(attributes.getValue(i), TRUE);
			c->phase = NULL;
			break;
		case attCONC_phase_si:
			c->phase_si = XMLCh2Double(attributes.getValue(i));
			break;		
		case attCONC_n_pe:
			c->n_pe = XMLCh2Int(attributes.getValue(i));
			break;
		case attCONC_as:
			c->as = XMLCh_hsave(attributes.getValue(i), TRUE);
			break;
		case attCONC_gfw:
			c->gfw = XMLCh2Double(attributes.getValue(i));
			break;		
	
		default:
			++input_error;
			string = xns::XMLString::transcode(attributes.getLocalName(i));
			sprintf(error_string, ERR_MSG, string);
			error_msg(error_string, CONTINUE);
			xns::XMLString::release(&string);
			break;
		}
	}
	return(OK);
}
int SaxPhreeqcHandlers::processMasterActivityAttributes(const xns::Attributes& attributes, struct master_activity *ma)
//int SaxPhreeqcHandlers::processMasterActivityAttributes(const xns::Attributes& attributes, std::vector<struct master_activity> *v)
{
	int i;
	char *string;
	const char ERR_MSG[] = "Unpacking master activity attributes: %s, attribute not found\n";	
	ma->description = NULL;
	ma->la = 0.0;
	attributeType attType;
	for (i = 0; i < (int) attributes.getLength(); i++) {
		attType = this->mapXMLCh2AttType[attributes.getLocalName(i)];

		switch (attType) {

			case attM_A_description:
				ma->description = XMLCh_hsave(attributes.getValue(i), TRUE);
				break;
			case attM_A_la:
				ma->la = XMLCh2Double(attributes.getValue(i));
				break;
			/*
			case attM_A_list:
				{
					struct master_activity ma;
					xns::BaseRefVectorOf<XMLCh> *arg = xns::XMLString::tokenizeString(attributes.getValue((unsigned int) 0));
				
					for ( i = 0; i < arg->size(); i+=2 ) {
						ma.description = XMLCh_hsave( arg->elementAt(i), TRUE);
						if (strcmp(ma.description, "null") == 0) {
								ma.description = NULL;
						}
						ma.la = XMLCh2Double( arg->elementAt(i+1));
						//this->acts.push_back(ma);
						(*v).push_back(ma);
					}
				}
				break;
			*/
			default:
				++input_error;
				string = xns::XMLString::transcode(attributes.getLocalName(i));
				sprintf(error_string, ERR_MSG, string);
				error_msg(error_string, CONTINUE);
				xns::XMLString::release(&string);
				break;
		}	
	}
	return (OK);
}
int SaxPhreeqcHandlers::processIsotopeAttributes(const xns::Attributes& attributes, struct isotope *iso)
{
	int i;
	char *string;
	const char ERR_MSG[] = "Unpacking isotope attributes: %s, attribute not found\n";	

	iso->primary = iso->master = NULL;
	iso->elt_name = iso->isotope_name = NULL;
	attributeType attType;
	for (i = 0; i < (int) attributes.getLength(); i++) {
		attType = this->mapXMLCh2AttType[attributes.getLocalName(i)];
		switch (attType) {
			case attISO_isotope_number:
				iso->isotope_number = XMLCh2Int(attributes.getValue(i));
				break;
			case attISO_elt_name:
				iso->elt_name = XMLCh_hsave(attributes.getValue(i), TRUE);
				break;
			case attISO_isotope_name:
				iso->isotope_name = XMLCh_hsave(attributes.getValue(i), TRUE);
				break;					
			case attISO_total:
				iso->total = XMLCh2Double(attributes.getValue(i));
				break;
			case attISO_ratio:
				iso->ratio = XMLCh2Double(attributes.getValue(i));
				break;
			case attISO_ratio_uncertainty:
				iso->ratio_uncertainty = XMLCh2Double(attributes.getValue(i));
				break;
			case attISO_coef:
				iso->coef = XMLCh2Double(attributes.getValue(i));
				break;

			default:
				++input_error;
				string = xns::XMLString::transcode(attributes.getLocalName(i));
				sprintf(error_string, ERR_MSG, string);
				error_msg(error_string, CONTINUE);		
				xns::XMLString::release(&string);
				break;
		}	
	}
	return (OK);
}