pyEQL 1.4.0rc9__cp310-cp310-win_amd64.whl

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/common/Parser.h

@@ -0,0 +1,310 @@
+#if !defined(PARSER_H_INCLUDED)
+#define PARSER_H_INCLUDED
+#if defined(WIN32)
+#  if defined(PHREEQCI_GUI)
+#    ifndef WINVER
+#      define WINVER 0x0400
+#    endif
+#    include <afx.h>
+#  endif
+#  include <windows.h>
+#endif
+#include <string>				// std::string
+#include <map>					// std::map
+#include <vector>				// std::vector
+#include <sstream>				// std::istringstream std::ostringstream
+#include <ostream>				// std::ostream
+#include <istream>				// std::istream
+#include <cctype>               // std::isspace
+#include <algorithm>            // std::find_if
+#include <functional>           // std::ptr_fun std::not1
+
+#include "PHRQ_base.h"
+#include "Keywords.h"
+#include "PHRQ_io.h"
+
+#ifdef _DEBUG
+#define isspace(a) isspace((a) < -1 ? (a) + 256 : (a)) 
+#define isupper(a) isupper((a) < -1 ? (a) + 256 : (a))
+#define islower(a) islower((a) < -1 ? (a) + 256 : (a)) 
+#define isdigit(a) isdigit((a) < -1 ? (a) + 256 : (a)) 
+#define isalpha(a) isalpha((a) < -1 ? (a) + 256 : (a))
+#endif
+
+class CParser: public PHRQ_base
+{
+  public:
+	CParser(PHRQ_io *io=NULL);
+	CParser(std::istream & input, PHRQ_io *io=NULL);
+	//CParser(std::istream & input, std::ostream & output, PHRQ_io *io=NULL);
+	//CParser(std::istream & input, std::ostream & output,
+	//		std::ostream & error, PHRQ_io *io=NULL);
+
+	virtual ~ CParser();
+	enum TOKEN_TYPE
+	{
+		TT_EMPTY = 2,
+		TT_UPPER = 4,
+		TT_LOWER = 5,
+		TT_DIGIT = 6,
+		TT_UNKNOWN = 7
+	};
+
+	enum FIND_TYPE
+	{
+		FT_OK = 0,
+		FT_ERROR = 1
+	};
+
+	enum OPT_TYPE
+	{
+		OPT_DEFAULT = -4,
+		OPT_ERROR = -3,
+		OPT_KEYWORD = -2,
+		OPT_EOF = -1
+	};
+	enum ECHO_OPTION
+	{
+		EO_NONE = 0,
+		EO_ALL = 1,
+		EO_KEYWORDS = 2,
+		EO_NOKEYWORDS = 3
+	};
+
+	enum STATUS_TYPE
+	{
+		PARSER_ERROR = 0,
+		PARSER_OK = 1
+	};
+
+
+		/**
+                Function gets a new line and checks for empty, eof, and keywords.
+
+                Arguments:
+                        string        Input, character string used in printing error message
+                        allow_empty   Input, True or false, if a blank line is acceptable
+                                      if false, another line is read
+                        allow_eof     Input, True or false, if EOF is acceptable
+                        allow_keyword Input, True or false, if a keyword is acceptable
+
+                Returns:
+                        LT_EMPTY         if empty line read and allow_empty == true
+                        LT_KEYWORD       if line begins with keyword
+                        LT_EOF           if eof and allow_eof == true
+                        LT_OK            otherwise
+                        LT_OPTION        if line begins with -[alpha]
+
+           Terminates       if EOF and allow_eof == false.
+        */
+	PHRQ_io::LINE_TYPE check_line(const std::string & str, bool allow_empty,
+						 bool allow_eof, bool allow_keyword, bool print);
+
+		/**
+                Read a line from input file put in "line".
+                Copy of input line is stored in "line_save".
+                Characters after # are discarded in line but retained in "line_save"
+
+                Arguments:
+                        None
+                Returns:
+                        LT_EMPTY,
+                        LT_EOF,
+                        LT_KEYWORD,
+                        LT_OK,
+                        LT_OPTION
+        */
+	PHRQ_io::LINE_TYPE get_line();
+	PHRQ_io::LINE_TYPE get_line_phrq_io();
+
+	// bool check_key(const std::string::iterator ptr);
+	bool check_key(std::string::iterator begin, std::string::iterator end);
+
+	STATUS_TYPE check_units(std::string & tot_units, bool alkalinity,
+							bool check_compatibility,
+							const std::string & default_units, bool print);
+
+
+	//KEY_TYPE next_keyword() const
+	Keywords::KEYWORDS next_keyword() const
+	{
+		return m_next_keyword;
+	}
+	int get_option(const std::vector < std::string > &opt_list,
+				   std::string::iterator & next_char);
+	int get_option(const std::vector < std::string > &opt_list,
+				   std::istream::pos_type & next_pos);
+	int getOptionFromLastLine(const std::vector < std::string > &opt_list,
+							  std::string::iterator & next_char, bool flag_error);
+	int getOptionFromLastLine(const std::vector < std::string > &opt_list,
+							  std::istream::pos_type & next_pos, bool flag_error);
+
+
+	std::string & line()
+	{
+		return m_line;
+	}
+	std::string & line_save()
+	{
+		return m_line_save;
+	}
+	std::string & get_accumulated()
+	{
+		return accumulated;
+	}
+	void set_accumulate(bool tf) 
+	{ 
+		if (tf)
+		{
+			accumulated.clear();
+		}
+		this->accumulate = tf; 
+	}
+	std::istringstream & get_iss()
+	{
+		return m_line_iss;
+	}
+	int incr_input_error();
+	int get_input_error()
+	{
+		return m_input_error;
+	}
+
+		/**
+                Copies from begin to token until first space is encountered.
+
+                Arguments:
+                        token    output, the token
+                        begin    input, begin iterator
+                        end      input, end iterator
+
+                Returns:
+                        TT_EMPTY
+                        TT_UPPER
+                        TT_LOWER
+                        TT_DIGIT
+                        TT_UNKNOWN
+        */
+	static CParser::TOKEN_TYPE copy_token(std::string & token,
+								 std::string::iterator & begin,
+								 std::string::iterator & end);
+	static CParser::TOKEN_TYPE copy_title(std::string & token,
+										std::string::iterator & begin,
+										std::string::iterator & end);
+	static CParser::TOKEN_TYPE token_type(const std::string & token);
+	static CParser::TOKEN_TYPE copy_token(std::string & token, std::istream & is);
+	CParser::TOKEN_TYPE copy_token(std::string & token, std::istream::pos_type & pos);
+	bool get_true_false(std::istream::pos_type & pos, bool def);
+	CParser::TOKEN_TYPE get_rest_of_line(std::string &token);
+	static CParser::TOKEN_TYPE parse_delimited(std::string & source, std::string & result, const std::string& t);
+	CParser::TOKEN_TYPE peek_token();
+	PHRQ_io::LINE_TYPE get_m_line_type(void) const {return this->m_line_type;}
+
+		/**
+                Function reads an element name out of the equation string.
+                An element name is composed of a capital letter followed by any number
+                of lower case characters.
+
+                Arguments:
+                        begin    input, points to position in the equation to begin
+                                        output, points to next character of equation after
+                                        element name.
+                        end      input, points to last position in the equation
+                        element  input pointer to place to return element character string
+        */
+	STATUS_TYPE get_elt(std::string::iterator & begin,
+						const std::string::iterator end,
+						std::string & element);
+
+
+		/**
+                Compares a string value to match beginning letters of a list of options
+
+                Arguments:
+                        item    entry: pointer to string to compare
+                        n       exit:  item in list that was matched
+                        list    entry: pointer to list of character values, assumed to
+                                be lower case
+                        count_list entry: number of character values in list
+
+                Returns:
+                        OK      item matched
+                        ERROR   item not matched
+                        n       -1      item not matched
+                                i       position of match in list
+        */
+	static FIND_TYPE find_option(const std::string & item, int *n,
+								 const std::vector < std::string > &list,
+								 bool exact);
+
+	void set_echo_file(ECHO_OPTION opt)
+	{
+		echo_file = opt;
+	}
+	ECHO_OPTION get_echo_file()
+	{
+		return this->echo_file;
+	};
+
+	void set_echo_stream(ECHO_OPTION opt)
+	{
+		echo_stream = opt;
+	}
+	ECHO_OPTION get_echo_stream()
+	{
+		return this->echo_stream;
+	};
+
+	STATUS_TYPE parse_couple(std::string & token);
+
+	template <class T>
+	STATUS_TYPE addPair(std::map < std::string, T >&totals,
+						std::istream::pos_type & pos);
+
+  protected:
+	PHRQ_io::LINE_TYPE get_logical_line();
+
+  protected:
+	std::istream & m_input_stream;
+	//std::ostream & m_output_stream;
+	//std::ostream & m_error_stream;
+	int m_input_error;
+	//KEY_TYPE m_next_keyword;
+	Keywords::KEYWORDS m_next_keyword;
+	std::string m_line;
+	std::string m_line_save;
+	std::istringstream m_line_iss;
+	PHRQ_io::LINE_TYPE m_line_type;
+	ECHO_OPTION echo_stream;
+	ECHO_OPTION echo_file;
+	std::string accumulated;
+	bool accumulate;
+	bool phrq_io_only;
+
+};
+
+// Global functions
+static inline std::string &trim_left(std::string &s)
+{ 
+#if (__GNUC__ && (__cplusplus >= 201103L)) || (_MSC_VER >= 1600)
+	s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int c) {return !std::isspace(c);}));
+#else
+	s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
+#endif
+	return s; 
+} 
+static inline std::string &trim_right(std::string &s)
+{ 
+#if (__GNUC__ && (__cplusplus >= 201103L)) || (_MSC_VER >= 1600)
+	s.erase(std::find_if(s.rbegin(), s.rend(), [](int c) {return !std::isspace(c);}).base(), s.end());
+#else
+	s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
+#endif
+	return s;
+} 
+static inline std::string &trim(std::string &s)
+{ 
+	return trim_left(trim_right(s)); 
+} 
+
+#endif // PARSER_H_INCLUDED

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/common/Utils.cxx

@@ -0,0 +1,263 @@
+#ifdef _DEBUG
+#pragma warning(disable : 4786)	// disable truncation warning (Only used by debugger)
+#endif
+#include <stdlib.h>				// ::tolower
+#include <ctype.h>				// ::tolower
+#include <algorithm>			// std::transform
+#include <iostream>				// std::cout std::cerr
+#include <string.h>
+
+#include "Utils.h"
+#include "Parser.h"
+#include "float.h"
+#include <cmath>
+
+#if defined(_MSC_VER) && (_MSC_VER <= 1400) // VS2005
+#  define nullptr NULL
+#endif
+
+#if __cplusplus < 201103L // Check if C++ standard is pre-C++11
+#  ifndef nullptr
+#    define nullptr NULL
+#  endif
+#endif
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+////////////////////////////////////////////////////////////////////////////
+int
+Utilities::strcmp_nocase_arg1(const char *str1, const char *str2)
+////////////////////////////////////////////////////////////////////////////
+{
+	//
+	// Compare two strings disregarding case
+	//
+	int c1, c2;
+	while ((c1 =::tolower(*str1++)) == (c2 = *str2++))
+	{
+		if (c1 == '\0')
+			return (0);
+	}
+	if (c1 < c2)
+		return (-1);
+	return (1);
+}
+
+////////////////////////////////////////////////////////////////////////////
+int
+Utilities::strcmp_nocase(const char *str1, const char *str2)
+////////////////////////////////////////////////////////////////////////////
+{
+	//
+	// Compare two strings disregarding case
+	//
+	int c1, c2;
+	while ((c1 =::tolower(*str1++)) == (c2 =::tolower(*str2++)))
+	{
+		if (c1 == '\0')
+			return (0);
+	}
+	if (c1 < c2)
+		return (-1);
+	return (1);
+}
+
+////////////////////////////////////////////////////////////////////////////
+void
+Utilities::str_tolower(std::string & str)
+////////////////////////////////////////////////////////////////////////////
+{
+	std::transform(str.begin(), str.end(), str.begin(), tolower);
+}
+
+////////////////////////////////////////////////////////////////////////////
+void
+Utilities::str_toupper(std::string & str)
+////////////////////////////////////////////////////////////////////////////
+{
+	std::transform(str.begin(), str.end(), str.begin(), toupper);
+}
+////////////////////////////////////////////////////////////////////////////
+std::string 
+Utilities::pad_right(const std::string & str, size_t l)
+////////////////////////////////////////////////////////////////////////////
+{
+	std::string new_str(str);
+	size_t length = new_str.size();
+	if (length < l)
+	{
+		new_str = new_str.insert(length, l - length, ' ');
+	}
+	return new_str;
+}
+
+
+////////////////////////////////////////////////////////////////////////////
+bool
+Utilities::replace(const char *str1, const char *str2, std::string & str)
+////////////////////////////////////////////////////////////////////////////
+{
+	std::string::size_type n = str.find(str1, 0);
+	if (n == std::string::npos)
+		return false;
+
+	str.replace(n, ::strlen(str1), str2);
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////
+void
+Utilities::squeeze_white(std::string & s_l)
+////////////////////////////////////////////////////////////////////////////
+{
+	std::string str;
+	std::string::iterator beg = s_l.begin();
+	std::string::iterator end = s_l.end();
+	//CParser::copy_token(str, beg, end);
+	std::string::iterator pos;
+	for (pos = beg; pos != end; pos++)
+	{
+		int c = *pos;
+		if (!::isspace(c))
+		{
+			str += c;
+		}
+	}
+	s_l = str;
+}
+////////////////////////////////////////////////////////////////////////////
+double 
+Utilities::convert_time(double t, std::string in, std::string out)
+////////////////////////////////////////////////////////////////////////////
+{
+	Utilities::str_tolower(in);
+
+	// convert t to seconds
+	if (in.substr(0,1) == "m")
+	{
+		t = t * 60.;
+	}
+	if (in.substr(0,1) == "h")
+	{
+		t = t * 3600.;
+	}
+	if (in.substr(0,1) == "d")
+	{
+		t = t * 3600. * 24.;
+	}
+	if (in.substr(0,1) == "y")
+	{
+		t = t * 3600. * 24. * 365.25;
+	}
+	// convert to output units
+	if (out.substr(0,1) == "m")
+	{
+		t = t / 60.;
+	}
+	if (out.substr(0,1) == "h")
+	{
+		t = t / 3600.;
+	}
+	if (out.substr(0,1) == "d")
+	{
+		t = t / ( 3600. * 24.);
+	}
+	if (out.substr(0,1) == "y")
+	{
+		t = t / (3600. * 24. * 365.25);
+	}
+	return t;
+
+}
+LDBLE 
+Utilities::safe_exp(LDBLE t)
+////////////////////////////////////////////////////////////////////////////
+{
+	LDBLE f = 1.442695*t; // convert to exp for 2.0
+
+	if (f > DBL_MAX_EXP - 50.0)
+	{
+		return pow(2, DBL_MAX_EXP - 50.0);
+	}
+	else if (f < DBL_MIN_EXP + 50.0)
+	{
+		return pow(2, DBL_MIN_EXP + 50.0);
+	}
+	return exp(t);
+}
+size_t Utilities::
+strcpy_safe(char* dest, size_t max, const char* src)
+{
+	size_t lsrc = 0;
+	try
+	{
+		if (dest == nullptr || src == nullptr)
+		{
+#if !defined(R_SO)
+			std::cerr << "nullptr in Utilities::strcpy_safe." << std::endl;
+#endif
+			throw;
+		}
+		lsrc = strlen(src);
+		if (lsrc + 1 > max)
+		{
+#if !defined(R_SO)
+			std::cerr << "Buffer overrun in Utilities::strcpy_safe." << std::endl;
+#endif
+			throw;
+		}
+		memcpy(dest, src, (lsrc + 1) * sizeof(char));
+	}
+	catch (...)
+	{
+		throw;
+	}
+	return lsrc;
+}
+size_t Utilities::
+strcat_safe(char* dest, size_t max, const char* src)
+{
+	size_t ldest = 0, lsrc = 0;
+	try
+	{
+		if (dest == nullptr || src == nullptr)
+		{
+#if !defined(R_SO)
+			std::cerr << "nullptr in Utilities::strcat_safe." << std::endl;
+#endif
+			throw;
+		}
+		lsrc = strlen(src);
+		ldest = strlen(dest);
+		if (ldest + lsrc + 1 > max)
+		{
+#if !defined(R_SO)
+			std::cerr << "Buffer overrun in Utilities::strcat_safe." << std::endl;
+#endif
+			throw;
+		}
+		memcpy(&dest[ldest], src, (lsrc + 1) * sizeof(char));
+	}
+	catch (...)
+	{
+		throw;
+	}
+	return ldest + lsrc;
+}
+//+NAN LDBLE: 7ff8000000000000
+//-NAN LDBLE: fff8000000000000
+/*
+LDBLE Utilities::get_nan(void)
+{
+	unsigned long long raw = 0x7ff0000000000000;
+	LDBLE d = *( LDBLE* )&raw;
+	return(d);
+
+}
+*/

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/common/Utils.h

@@ -0,0 +1,29 @@
+#if !defined(UTILITIES_H_INCLUDED)
+#define UTILITIES_H_INCLUDED
+
+#include <string>
+#include <sstream>				// std::istringstream std::ostringstream
+#include <ostream>				// std::ostream
+#include <istream>				// std::istream
+#include <map>					// std::map
+#include "phrqtype.h"
+namespace Utilities
+{
+
+	const char INDENT[] = "  ";
+
+	int strcmp_nocase(const char *str1, const char *str2);
+
+	int strcmp_nocase_arg1(const char *str1, const char *str2);
+
+	void str_tolower(std::string & str);
+	void str_toupper(std::string & str);
+	std::string pad_right(const std::string & str, size_t l);
+	bool replace(const char *str1, const char *str2, std::string & str);
+	size_t strcat_safe(char* dest, size_t max, const char* src);
+	size_t strcpy_safe(char* dest, size_t max, const char* src);
+	void squeeze_white(std::string & s_l);
+	double convert_time(double t, std::string in, std::string out);
+	LDBLE safe_exp(LDBLE t);
+}
+#endif // UTILITIES_H_INCLUDED

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/common/phrqtype.h

@@ -0,0 +1,18 @@
+#ifndef _INC_PHRQTYPE_H
+#define _INC_PHRQTYPE_H
+/*
+ *   The following implements long double
+ *   Many machines long double = double so there is no advantage
+ *   Check float.h include file for number of digits (LDBL_DIG)
+ *   Need to define here and in cl1.c
+ */
+
+/*#define USE_LONG_DOUBLE*/
+#ifdef USE_LONG_DOUBLE
+#define LDBLE long double
+#define SCANFORMAT "%Lf"
+#else
+#define LDBLE double
+#define SCANFORMAT "%lf"
+#endif
+#endif /* _INC_PHRQTYPE_H */