max/iphreeqc
1
0
Fork 0
mirror of https://git.gfz-potsdam.de/naaice/iphreeqc.git synced 2025-12-16 16:44:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

Moved keywords to separate class

Browse Source 
git-svn-id: svn://136.177.114.72/svn_GW/phreeqcpp/branches/ErrorHandling@5835 1feff8c3-07ed-0310-ac33-dd36852eb9cd
This commit is contained in:
David L Parkhurst 2011-11-30 18:30:51 +00:00
parent 584b79bd5d
commit 17a4c8442d
5 changed files with 127 additions and 366 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
Parser.cxx
View File

@ -12,8 +12,8 @@
#include <iostream> // std::cout std::cerr
#include "Utils.h"
#include <stdio.h>
#include "Phreeqc.h"
#include "Parser.h"
#include "Phreeqc.h"
#include "PHRQ_io.h"
//////////////////////////////////////////////////////////////////////
@ -26,7 +26,7 @@ m_input_stream(input),
m_output_stream(std::cout),
m_error_stream(std::cerr),
m_input_error(0),
m_next_keyword(KT_NONE)
m_next_keyword(Keywords::KEY_NONE)
{
m_line_save.reserve(80);
m_line.reserve(80);
@ -42,7 +42,7 @@ m_input_stream(input),
m_output_stream(output),
m_error_stream(std::cerr),
m_input_error(0),
m_next_keyword(KT_NONE)
m_next_keyword(Keywords::KEY_NONE)
{
m_line_save.reserve(80);
m_line.reserve(80);
@ -58,7 +58,7 @@ m_input_stream(input),
m_output_stream(output),
m_error_stream(error),
m_input_error(0),
m_next_keyword(KT_NONE)
m_next_keyword(Keywords::KEY_NONE)
{
m_line_save.reserve(80);
m_line.reserve(80);
@ -127,7 +127,7 @@ CParser::LINE_TYPE CParser::check_line(const std::string & str,
{
std::ostringstream msg;
msg << "\t" << m_line_save << "\n";
this->output_msg(msg.str());
this->echo_msg(msg.str());
}
break;
case EO_KEYWORDS:
@ -135,7 +135,7 @@ CParser::LINE_TYPE CParser::check_line(const std::string & str,
{
std::ostringstream msg;
msg << "\t" << m_line_save << "\n";
this->output_msg(msg.str());
this->echo_msg(msg.str());
}
break;
@ -144,7 +144,7 @@ CParser::LINE_TYPE CParser::check_line(const std::string & str,
{
std::ostringstream msg;
msg << "\t" << m_line_save << "\n";
this->output_msg(msg.str().c_str());
this->echo_msg(msg.str().c_str());
}
break;
}
@ -197,7 +197,7 @@ CParser::LINE_TYPE CParser::get_line()
//{{MOD
m_line.erase(m_line.begin(), m_line.end()); // m_line.clear();
//}}MOD
m_next_keyword = KT_EOF;
m_next_keyword = Keywords::KEY_END;
return LT_EOF;
}
}
@ -341,54 +341,59 @@ CParser::LINE_TYPE CParser::get_logical_line()
bool
CParser::check_key(std::string::iterator begin, std::string::iterator end)
{
static std::map < std::string, KEY_TYPE > s_keyword_map;
if (s_keyword_map.size() == 0)
{
s_keyword_map.insert(std::map < std::string,
KEY_TYPE >::value_type("solution_raw",
KT_SOLUTION_RAW));
s_keyword_map.insert(std::map < std::string,
KEY_TYPE >::value_type("exchange_raw",
KT_EXCHANGE_RAW));
s_keyword_map.insert(std::map < std::string,
KEY_TYPE >::value_type("gas_phase_raw",
KT_GASPHASE_RAW));
s_keyword_map.insert(std::map < std::string,
KEY_TYPE >::value_type("kinetics_raw",
KT_KINETICS_RAW));
s_keyword_map.insert(std::map < std::string,
KEY_TYPE >::value_type("equilibrium_phases_raw",
KT_PPASSEMBLAGE_RAW));
s_keyword_map.insert(std::map < std::string,
KEY_TYPE >::value_type("solid_solutions_raw",
KT_SSASSEMBLAGE_RAW));
s_keyword_map.insert(std::map < std::string,
KEY_TYPE >::value_type("surface_raw",
KT_SURFACE_RAW));
s_keyword_map.insert(std::map < std::string,
KEY_TYPE >::value_type("reaction_temperature_raw",
KT_TEMPERATURE_RAW));
s_keyword_map.insert(std::map < std::string,
KEY_TYPE >::value_type("reaction_raw",
KT_REACTION_RAW));
#if defined MULTICHART
s_keyword_map.insert(std::map < std::string,
KEY_TYPE >::value_type("user_graph",
KT_USER_GRAPH));
#endif
}
// static std::map < std::string, KEY_TYPE > s_keyword_map;
// if (s_keyword_map.size() == 0)
// {
// s_keyword_map.insert(std::map < std::string,
// KEY_TYPE >::value_type("solution_raw",
// KT_SOLUTION_RAW));
// s_keyword_map.insert(std::map < std::string,
// KEY_TYPE >::value_type("exchange_raw",
// KT_EXCHANGE_RAW));
// s_keyword_map.insert(std::map < std::string,
// KEY_TYPE >::value_type("gas_phase_raw",
// KT_GASPHASE_RAW));
// s_keyword_map.insert(std::map < std::string,
// KEY_TYPE >::value_type("kinetics_raw",
// KT_KINETICS_RAW));
// s_keyword_map.insert(std::map < std::string,
// KEY_TYPE >::value_type("equilibrium_phases_raw",
// KT_PPASSEMBLAGE_RAW));
// s_keyword_map.insert(std::map < std::string,
// KEY_TYPE >::value_type("solid_solutions_raw",
// KT_SSASSEMBLAGE_RAW));
// s_keyword_map.insert(std::map < std::string,
// KEY_TYPE >::value_type("surface_raw",
// KT_SURFACE_RAW));
// s_keyword_map.insert(std::map < std::string,
// KEY_TYPE >::value_type("reaction_temperature_raw",
// KT_TEMPERATURE_RAW));
// s_keyword_map.insert(std::map < std::string,
// KEY_TYPE >::value_type("reaction_raw",
// KT_REACTION_RAW));
//#if defined MULTICHART
// s_keyword_map.insert(std::map < std::string,
// KEY_TYPE >::value_type("user_graph",
// KT_USER_GRAPH));
//#endif
// }
std::string lowercase;
copy_token(lowercase, begin, end);
std::transform(lowercase.begin(), lowercase.end(), lowercase.begin(),
tolower);
m_next_keyword = KT_NONE;
std::map < std::string, KEY_TYPE >::iterator map_iter =
s_keyword_map.find(lowercase);
if (map_iter == s_keyword_map.end())
//m_next_keyword = Keywords::KEY_NONE;
//std::map < std::string, KEY_TYPE >::iterator map_iter =
// s_keyword_map.find(lowercase);
//if (map_iter == s_keyword_map.end())
// return false;
//m_next_keyword = (*map_iter).second;
m_next_keyword = Keywords::Keyword_search(lowercase);
if (m_next_keyword == Keywords::KEY_NONE)
{
return false;
m_next_keyword = (*map_iter).second;
}
return true;
}

49
Parser.h
View File

@ -1,5 +1,8 @@
#if !defined(PARSER_H_INCLUDED)
#define PARSER_H_INCLUDED
#if defined(WIN32)
#include <windows.h>
#endif
#include <string> // std::string
#include <map> // std::map
@ -8,6 +11,8 @@
#include <ostream> // std::ostream
#include <istream> // std::istream
#include "PHRQ_base.h"
#include "Keywords.h"
class CParser: public PHRQ_base
{
@ -43,25 +48,25 @@ class CParser: public PHRQ_base
FT_ERROR = 1
};
enum KEY_TYPE
{
KT_NONE = -1,
KT_END = 0,
KT_EOF = 1,
KT_SOLUTION_RAW = 5,
KT_EXCHANGE_RAW = 6,
KT_GASPHASE_RAW = 7,
KT_KINETICS_RAW = 8,
KT_PPASSEMBLAGE_RAW = 9,
KT_SSASSEMBLAGE_RAW = 10,
KT_SURFACE_RAW = 11,
KT_TEMPERATURE_RAW = 12,
KT_REACTION_RAW = 13,
KT_MIX_RAW = 14
#if defined MULTICHART
, KT_USER_GRAPH = 15
#endif
};
// enum KEY_TYPE
// {
// KT_NONE = -1,
// KT_END = 0,
// KT_EOF = 1,
// KT_SOLUTION_RAW = 5,
// KT_EXCHANGE_RAW = 6,
// KT_GASPHASE_RAW = 7,
// KT_KINETICS_RAW = 8,
// KT_PPASSEMBLAGE_RAW = 9,
// KT_SSASSEMBLAGE_RAW = 10,
// KT_SURFACE_RAW = 11,
// KT_TEMPERATURE_RAW = 12,
// KT_REACTION_RAW = 13,
// KT_MIX_RAW = 14
//#if defined MULTICHART
// , KT_USER_GRAPH = 15
//#endif
// };
enum OPT_TYPE
{
@ -138,7 +143,8 @@ class CParser: public PHRQ_base
const std::string & default_units, bool print);
KEY_TYPE next_keyword() const
//KEY_TYPE next_keyword() const
Keywords::KEYWORDS next_keyword() const
{
return m_next_keyword;
}
@ -291,7 +297,8 @@ class CParser: public PHRQ_base
std::ostream & m_output_stream;
std::ostream & m_error_stream;
int m_input_error;
KEY_TYPE m_next_keyword;
//KEY_TYPE m_next_keyword;
Keywords::KEYWORDS m_next_keyword;
std::string m_line;
std::string m_line_save;
std::istringstream m_line_iss;

192
Phreeqc.cpp
View File

@ -69,7 +69,7 @@ Phreeqc::Phreeqc(void)
}
// counters for enum KEYWORDS
for (i = 0; i < KEY_COUNT_KEYWORDS; i++)
for (i = 0; i < Keywords::KEY_COUNT_KEYWORDS; i++)
{
keycount.push_back(0);
}
@ -872,193 +872,3 @@ void Phreeqc::init(void)
return;
}
Phreeqc::KEYWORDS Phreeqc::Keyword_search(std::string key)
{
std::map<const std::string, Phreeqc::KEYWORDS>::const_iterator it;
it = phreeqc_keywords.find(key);
if (it != Phreeqc::phreeqc_keywords.end())
{
return it->second;
}
return Phreeqc::KEY_NONE;
}
const std::string & Phreeqc::Keyword_name_search(Phreeqc::KEYWORDS key)
{
std::map<Phreeqc::KEYWORDS, const std::string>::const_iterator it;
it = phreeqc_keyword_names.find(key);
if (it != Phreeqc::phreeqc_keyword_names.end())
{
return it->second;
}
it = phreeqc_keyword_names.find(KEY_NONE);
return it->second;
}
const std::map<const std::string, Phreeqc::KEYWORDS>::value_type temp_keywords[] = {
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("eof", Phreeqc::KEY_END),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("end", Phreeqc::KEY_END),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solution_species", Phreeqc::KEY_SOLUTION_SPECIES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solution_master_species", Phreeqc::KEY_SOLUTION_MASTER_SPECIES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solution", Phreeqc::KEY_SOLUTION),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("phases", Phreeqc::KEY_PHASES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("pure_phases", Phreeqc::KEY_EQUILIBRIUM_PHASES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("reaction", Phreeqc::KEY_REACTION),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("mix", Phreeqc::KEY_MIX),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("use", Phreeqc::KEY_USE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("save", Phreeqc::KEY_SAVE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("exchange_species", Phreeqc::KEY_EXCHANGE_SPECIES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("exchange_master_species", Phreeqc::KEY_EXCHANGE_MASTER_SPECIES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("exchange", Phreeqc::KEY_EXCHANGE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("surface_species", Phreeqc::KEY_SURFACE_SPECIES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("surface_master_species", Phreeqc::KEY_SURFACE_MASTER_SPECIES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("surface", Phreeqc::KEY_SURFACE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("reaction_temperature", Phreeqc::KEY_REACTION_TEMPERATURE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("inverse_modeling", Phreeqc::KEY_INVERSE_MODELING),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("gas_phase", Phreeqc::KEY_GAS_PHASE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("transport", Phreeqc::KEY_TRANSPORT),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("debug", Phreeqc::KEY_KNOBS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("selected_output", Phreeqc::KEY_SELECTED_OUTPUT),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("select_output", Phreeqc::KEY_SELECTED_OUTPUT),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("knobs", Phreeqc::KEY_KNOBS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("print", Phreeqc::KEY_PRINT),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("equilibrium_phases", Phreeqc::KEY_EQUILIBRIUM_PHASES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("equilibria", Phreeqc::KEY_EQUILIBRIUM_PHASES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("equilibrium", Phreeqc::KEY_EQUILIBRIUM_PHASES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("pure", Phreeqc::KEY_EQUILIBRIUM_PHASES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("title", Phreeqc::KEY_TITLE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("comment", Phreeqc::KEY_TITLE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("advection", Phreeqc::KEY_ADVECTION),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("kinetics", Phreeqc::KEY_KINETICS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("incremental_reactions", Phreeqc::KEY_INCREMENTAL_REACTIONS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("incremental", Phreeqc::KEY_INCREMENTAL_REACTIONS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("rates", Phreeqc::KEY_RATES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solution_s", Phreeqc::KEY_SOLUTION_SPREAD),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("user_print", Phreeqc::KEY_USER_PRINT),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("user_punch", Phreeqc::KEY_USER_PUNCH),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solid_solutions", Phreeqc::KEY_SOLID_SOLUTIONS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solid_solution", Phreeqc::KEY_SOLID_SOLUTIONS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solution_spread", Phreeqc::KEY_SOLUTION_SPREAD),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("spread_solution", Phreeqc::KEY_SOLUTION_SPREAD),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("selected_out", Phreeqc::KEY_SELECTED_OUTPUT),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("select_out", Phreeqc::KEY_SELECTED_OUTPUT),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("user_graph", Phreeqc::KEY_USER_GRAPH),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("llnl_aqueous_model_parameters", Phreeqc::KEY_LLNL_AQUEOUS_MODEL_PARAMETERS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("llnl_aqueous_model", Phreeqc::KEY_LLNL_AQUEOUS_MODEL_PARAMETERS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("database", Phreeqc::KEY_DATABASE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("named_analytical_expression", Phreeqc::KEY_NAMED_EXPRESSIONS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("named_analytical_expressions", Phreeqc::KEY_NAMED_EXPRESSIONS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("named_expressions", Phreeqc::KEY_NAMED_EXPRESSIONS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("named_log_k", Phreeqc::KEY_NAMED_EXPRESSIONS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("isotopes", Phreeqc::KEY_ISOTOPES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("calculate_values", Phreeqc::KEY_CALCULATE_VALUES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("isotope_ratios", Phreeqc::KEY_ISOTOPE_RATIOS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("isotope_alphas", Phreeqc::KEY_ISOTOPE_ALPHAS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("copy", Phreeqc::KEY_COPY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("pitzer", Phreeqc::KEY_PITZER),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("sit", Phreeqc::KEY_SIT),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("equilibrium_phase", Phreeqc::KEY_EQUILIBRIUM_PHASES),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solution_raw", Phreeqc::KEY_SOLUTION_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("exchange_raw", Phreeqc::KEY_EXCHANGE_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("surface_raw", Phreeqc::KEY_SURFACE_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("equilibrium_phases_raw", Phreeqc::KEY_EQUILIBRIUM_PHASES_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("kinetics_raw", Phreeqc::KEY_KINETICS_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solid_solutions_raw", Phreeqc::KEY_SOLID_SOLUTIONS_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("gas_phase_raw", Phreeqc::KEY_GAS_PHASE_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("reaction_raw", Phreeqc::KEY_REACTION_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("mix_raw", Phreeqc::KEY_MIX_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("reaction_temperature_raw", Phreeqc::KEY_REACTION_TEMPERATURE_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("dump", Phreeqc::KEY_DUMP),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solution_modify", Phreeqc::KEY_SOLUTION_MODIFY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("equilibrium_phases_modify", Phreeqc::KEY_EQUILIBRIUM_PHASES_MODIFY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("exchange_modify", Phreeqc::KEY_EXCHANGE_MODIFY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("surface_modify", Phreeqc::KEY_SURFACE_MODIFY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solid_solutions_modify", Phreeqc::KEY_SOLID_SOLUTIONS_MODIFY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("gas_phase_modify", Phreeqc::KEY_GAS_PHASE_MODIFY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("kinetics_modify", Phreeqc::KEY_KINETICS_MODIFY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("delete", Phreeqc::KEY_DELETE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("run_cells", Phreeqc::KEY_RUN_CELLS),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("reaction_modify", Phreeqc::KEY_REACTION_MODIFY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("reaction_temperature_modify", Phreeqc::KEY_REACTION_TEMPERATURE_MODIFY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("solid_solution_modify", Phreeqc::KEY_SOLID_SOLUTION_MODIFY),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("reaction_pressure", Phreeqc::KEY_REACTION_PRESSURE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("reaction_pressures", Phreeqc::KEY_REACTION_PRESSURE),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("reaction_pressure_raw", Phreeqc::KEY_REACTION_PRESSURE_RAW),
std::map<const std::string, Phreeqc::KEYWORDS>::value_type("reaction_pressure_modify", Phreeqc::KEY_REACTION_PRESSURE_MODIFY)
};
std::map<const std::string, Phreeqc::KEYWORDS> Phreeqc::phreeqc_keywords(temp_keywords, temp_keywords + sizeof temp_keywords / sizeof temp_keywords[0]);
const std::map<Phreeqc::KEYWORDS, std::string>::value_type temp_keyword_names[] = {
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_NONE, "UNKNOWN"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_END, "END"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SOLUTION_SPECIES, "SOLUTION_SPECIES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SOLUTION_MASTER_SPECIES, "SOLUTION_MASTER_SPECIES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SOLUTION, "SOLUTION"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_PHASES, "PHASES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_REACTION, "REACTION"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_MIX, "MIX"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_USE, "USE"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SAVE, "SAVE"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_EXCHANGE_SPECIES, "EXCHANGE_SPECIES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_EXCHANGE_MASTER_SPECIES, "EXCHANGE_MASTER_SPECIES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_EXCHANGE, "EXCHANGE"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SURFACE_SPECIES, "SURFACE_SPECIES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SURFACE_MASTER_SPECIES, "SURFACE_MASTER_SPECIES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SURFACE, "SURFACE"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_REACTION_TEMPERATURE, "REACTION_TEMPERATURE"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_INVERSE_MODELING, "INVERSE_MODELING"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_GAS_PHASE, "GAS_PHASE"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_TRANSPORT, "TRANSPORT"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SELECTED_OUTPUT, "SELECTED_OUTPUT"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_KNOBS, "KNOBS"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_PRINT, "PRINT"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_EQUILIBRIUM_PHASES, "EQUILIBRIUM_PHASES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_TITLE, "TITLE"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_ADVECTION, "ADVECTION"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_KINETICS, "KINETICS"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_INCREMENTAL_REACTIONS, "INCREMENTAL_REACTIONS"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_RATES, "RATES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_USER_PRINT, "USER_PRINT"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_USER_PUNCH, "USER_PUNCH"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SOLID_SOLUTIONS, "SOLID_SOLUTIONS"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SOLUTION_SPREAD, "SOLUTION_SPREAD"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_USER_GRAPH, "USER_GRAPH"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_LLNL_AQUEOUS_MODEL_PARAMETERS, "LLNL_AQUEOUS_MODEL_PARAMETERS"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_DATABASE, "DATABASE"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_NAMED_EXPRESSIONS, "NAMED_EXPRESSIONS"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_ISOTOPES, "ISOTOPES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_CALCULATE_VALUES, "CALCULATE_VALUES"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_ISOTOPE_RATIOS, "ISOTOPE_RATIOS"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_ISOTOPE_ALPHAS, "ISOTOPE_ALPHAS"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_COPY, "COPY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_PITZER, "PITZER"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SIT, "SIT"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SOLUTION_RAW, "SOLUTION_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_EXCHANGE_RAW, "EXCHANGE_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SURFACE_RAW, "SURFACE_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_EQUILIBRIUM_PHASES_RAW, "EQUILIBRIUM_PHASES_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_KINETICS_RAW, "KINETICS_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SOLID_SOLUTIONS_RAW, "SOLID_SOLUTIONS_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_GAS_PHASE_RAW, "GAS_PHASE_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_REACTION_RAW, "REACTION_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_MIX_RAW, "MIX_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_REACTION_TEMPERATURE_RAW, "REACTION_TEMPERATURE_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_DUMP, "DUMP"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SOLUTION_MODIFY, "SOLUTION_MODIFY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_EQUILIBRIUM_PHASES_MODIFY, "EQUILIBRIUM_PHASES_MODIFY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_EXCHANGE_MODIFY, "EXCHANGE_MODIFY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SURFACE_MODIFY, "SURFACE_MODIFY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SOLID_SOLUTIONS_MODIFY, "SOLID_SOLUTIONS_MODIFY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_GAS_PHASE_MODIFY, "GAS_PHASE_MODIFY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_KINETICS_MODIFY, "KINETICS_MODIFY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_DELETE, "DELETE"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_RUN_CELLS, "RUN_CELLS"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_REACTION_MODIFY, "REACTION_MODIFY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_REACTION_TEMPERATURE_MODIFY, "REACTION_TEMPERATURE_MODIFY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_SOLID_SOLUTION_MODIFY, "SOLID_SOLUTION_MODIFY"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_REACTION_PRESSURE, "REACTION_PRESSURE"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_REACTION_PRESSURE_RAW, "REACTION_PRESSURE_RAW"),
std::map<Phreeqc::KEYWORDS, const std::string>::value_type(Phreeqc::KEY_REACTION_PRESSURE_MODIFY, "REACTION_PRESSURE_MODIFY")
};
std::map<Phreeqc::KEYWORDS, const std::string> Phreeqc::phreeqc_keyword_names(temp_keyword_names, temp_keyword_names + sizeof temp_keyword_names / sizeof temp_keyword_names[0]);

80
Phreeqc.h
View File

@ -59,86 +59,10 @@ public:
Phreeqc(void);
~Phreeqc(void);
enum KEYWORDS
{
KEY_NONE,
KEY_END,
KEY_SOLUTION_SPECIES,
KEY_SOLUTION_MASTER_SPECIES,
KEY_SOLUTION,
KEY_PHASES,
KEY_REACTION,
KEY_MIX,
KEY_USE,
KEY_SAVE,
KEY_EXCHANGE_SPECIES,
KEY_EXCHANGE_MASTER_SPECIES,
KEY_EXCHANGE,
KEY_SURFACE_SPECIES,
KEY_SURFACE_MASTER_SPECIES,
KEY_SURFACE,
KEY_REACTION_TEMPERATURE,
KEY_INVERSE_MODELING,
KEY_GAS_PHASE,
KEY_TRANSPORT,
KEY_SELECTED_OUTPUT,
KEY_KNOBS,
KEY_PRINT,
KEY_EQUILIBRIUM_PHASES,
KEY_TITLE,
KEY_ADVECTION,
KEY_KINETICS,
KEY_INCREMENTAL_REACTIONS,
KEY_RATES,
KEY_USER_PRINT,
KEY_USER_PUNCH,
KEY_SOLID_SOLUTIONS,
KEY_SOLUTION_SPREAD,
KEY_USER_GRAPH,
KEY_LLNL_AQUEOUS_MODEL_PARAMETERS,
KEY_DATABASE,
KEY_NAMED_EXPRESSIONS,
KEY_ISOTOPES,
KEY_CALCULATE_VALUES,
KEY_ISOTOPE_RATIOS,
KEY_ISOTOPE_ALPHAS,
KEY_COPY,
KEY_PITZER,
KEY_SIT,
KEY_SOLUTION_RAW,
KEY_EXCHANGE_RAW,
KEY_SURFACE_RAW,
KEY_EQUILIBRIUM_PHASES_RAW,
KEY_KINETICS_RAW,
KEY_SOLID_SOLUTIONS_RAW,
KEY_GAS_PHASE_RAW,
KEY_REACTION_RAW,
KEY_MIX_RAW,
KEY_REACTION_TEMPERATURE_RAW,
KEY_DUMP,
KEY_SOLUTION_MODIFY,
KEY_EQUILIBRIUM_PHASES_MODIFY,
KEY_EXCHANGE_MODIFY,
KEY_SURFACE_MODIFY,
KEY_SOLID_SOLUTIONS_MODIFY,
KEY_GAS_PHASE_MODIFY,
KEY_KINETICS_MODIFY,
KEY_DELETE,
KEY_RUN_CELLS,
KEY_REACTION_MODIFY,
KEY_REACTION_TEMPERATURE_MODIFY,
KEY_SOLID_SOLUTION_MODIFY,
KEY_REACTION_PRESSURE,
KEY_REACTION_PRESSURE_RAW,
KEY_REACTION_PRESSURE_MODIFY,
KEY_COUNT_KEYWORDS // must be last in list
};
public:
//
// Phreeqc class methods
//
static Phreeqc::KEYWORDS Keyword_search(std::string key);
static const std::string & Phreeqc::Keyword_name_search(Phreeqc::KEYWORDS key);
// advection.cpp -------------------------------
int advection(void);
@ -1828,7 +1752,7 @@ protected:
int input_error;
KEYWORDS next_keyword;
Keywords::KEYWORDS next_keyword;
int parse_error;
int paren_count;
int iterations;
@ -2149,8 +2073,6 @@ public:
friend class ChartObject;
std::vector<int> keycount; // used to mark keywords that have been read
static std::map<const std::string, KEYWORDS> phreeqc_keywords;
static std::map<Phreeqc::KEYWORDS, const std::string> phreeqc_keyword_names;
#endif /* _INC_PHREEQC_H */

69
StorageBin.cxx
View File

@ -492,9 +492,11 @@ cxxStorageBin::read_raw(CParser & parser)
{
switch (parser.next_keyword())
{
case CParser::KT_END:
case CParser::KT_EOF:
case CParser::KT_NONE:
//case CParser::KT_END:
//case CParser::KT_EOF:
//case CParser::KT_NONE:
case Keywords::KEY_END:
case Keywords::KEY_NONE:
goto END_OF_SIMULATION_INPUT;
break;
/*
@ -508,7 +510,8 @@ cxxStorageBin::read_raw(CParser & parser)
KT_TEMPERATURE_RAW = 12,
KT_REACTION_RAW = 13
*/
case CParser::KT_SOLUTION_RAW:
//case CParser::KT_SOLUTION_RAW:
case Keywords::KEY_SOLUTION_RAW:
{
cxxSolution entity(this->Get_io());
entity.read_raw(parser);
@ -516,7 +519,8 @@ cxxStorageBin::read_raw(CParser & parser)
}
break;
case CParser::KT_EXCHANGE_RAW:
//case CParser::KT_EXCHANGE_RAW:
case Keywords::KEY_EXCHANGE_RAW:
{
cxxExchange entity(this->Get_io());
entity.read_raw(parser);
@ -524,7 +528,8 @@ cxxStorageBin::read_raw(CParser & parser)
}
break;
case CParser::KT_GASPHASE_RAW:
//case CParser::KT_GASPHASE_RAW:
case Keywords::KEY_GAS_PHASE_RAW:
{
cxxGasPhase entity(this->Get_io());
entity.read_raw(parser);
@ -532,7 +537,8 @@ cxxStorageBin::read_raw(CParser & parser)
}
break;
case CParser::KT_KINETICS_RAW:
//case CParser::KT_KINETICS_RAW:
case Keywords::KEY_KINETICS_RAW:
{
cxxKinetics entity(this->Get_io());
entity.read_raw(parser);
@ -540,7 +546,7 @@ cxxStorageBin::read_raw(CParser & parser)
}
break;
case CParser::KT_PPASSEMBLAGE_RAW:
case Keywords::KEY_EQUILIBRIUM_PHASES_RAW:
{
cxxPPassemblage entity(this->Get_io());
entity.read_raw(parser);
@ -548,7 +554,7 @@ cxxStorageBin::read_raw(CParser & parser)
}
break;
case CParser::KT_SSASSEMBLAGE_RAW:
case Keywords::KEY_SOLID_SOLUTIONS_RAW:
{
cxxSSassemblage entity;
entity.read_raw(parser);
@ -556,7 +562,7 @@ cxxStorageBin::read_raw(CParser & parser)
}
break;
case CParser::KT_SURFACE_RAW:
case Keywords::KEY_SURFACE_RAW:
{
cxxSurface entity(this->Get_io());
entity.read_raw(parser);
@ -564,7 +570,7 @@ cxxStorageBin::read_raw(CParser & parser)
}
break;
case CParser::KT_TEMPERATURE_RAW:
case Keywords::KEY_REACTION_TEMPERATURE_RAW:
{
cxxTemperature entity(this->Get_io());
entity.read_raw(parser);
@ -572,14 +578,14 @@ cxxStorageBin::read_raw(CParser & parser)
}
break;
case CParser::KT_REACTION_RAW:
case Keywords::KEY_REACTION_RAW:
{
cxxReaction entity;
entity.read_raw(parser, true);
Reactions[entity.Get_n_user()] = entity;
}
break;
case CParser::KT_MIX_RAW:
case Keywords::KEY_MIX_RAW:
{
cxxMix entity;
entity.read_raw(parser);
@ -603,8 +609,10 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
switch (parser.next_keyword())
{
case CParser::KT_NONE:
case CParser::KT_END:
//case CParser::KT_NONE:
//case CParser::KT_END:
case Keywords::KEY_NONE:
case Keywords::KEY_END:
while ((i =
parser.check_line("StorageBin read_raw_keyword", false, true,
true, true)) != CParser::LT_KEYWORD)
@ -613,8 +621,8 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
break; // CParser::LT_EOF;
}
break;
case CParser::KT_EOF:
break;
/*case CParser::KT_EOF:
break;*/
/*
KT_SOLUTION_RAW = 5,
KT_EXCHANGE_RAW = 6,
@ -626,7 +634,7 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
KT_TEMPERATURE_RAW = 12,
KT_REACTION_RAW = 13
*/
case CParser::KT_SOLUTION_RAW:
case Keywords::KEY_SOLUTION_RAW:
{
cxxSolution entity(this->Get_io());
entity.read_raw(parser);
@ -635,7 +643,7 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
}
break;
case CParser::KT_EXCHANGE_RAW:
case Keywords::KEY_EXCHANGE_RAW:
{
cxxExchange entity(this->Get_io());
entity.read_raw(parser);
@ -644,7 +652,7 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
}
break;
case CParser::KT_GASPHASE_RAW:
case Keywords::KEY_GAS_PHASE_RAW:
{
cxxGasPhase entity(this->Get_io());
entity.read_raw(parser);
@ -653,7 +661,7 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
}
break;
case CParser::KT_KINETICS_RAW:
case Keywords::KEY_KINETICS_RAW:
{
cxxKinetics entity(this->Get_io());
entity.read_raw(parser);
@ -662,7 +670,7 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
}
break;
case CParser::KT_PPASSEMBLAGE_RAW:
case Keywords::KEY_EQUILIBRIUM_PHASES_RAW:
{
cxxPPassemblage entity(this->Get_io());
entity.read_raw(parser);
@ -671,7 +679,7 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
}
break;
case CParser::KT_SSASSEMBLAGE_RAW:
case Keywords::KEY_SOLID_SOLUTIONS_RAW:
{
cxxSSassemblage entity;
entity.read_raw(parser);
@ -680,7 +688,7 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
}
break;
case CParser::KT_SURFACE_RAW:
case Keywords::KEY_SURFACE_RAW:
{
cxxSurface entity(this->Get_io());
entity.read_raw(parser);
@ -689,7 +697,7 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
}
break;
case CParser::KT_TEMPERATURE_RAW:
case Keywords::KEY_REACTION_TEMPERATURE_RAW:
{
cxxTemperature entity(this->Get_io());
entity.read_raw(parser);
@ -698,7 +706,7 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
}
break;
case CParser::KT_REACTION_RAW:
case Keywords::KEY_REACTION_RAW:
{
cxxReaction entity;
entity.read_raw(parser, true);
@ -707,6 +715,15 @@ cxxStorageBin::read_raw_keyword(CParser & parser)
}
break;
case Keywords::KEY_MIX_RAW:
{
cxxMix entity;
entity.read_raw(parser);
Mixes[entity.Get_n_user()] = entity;
entity_number = entity.Get_n_user();
}
break;
default:
break;
}