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

merged in IPhreeqc-class 4140-4239

Browse Source 
git-svn-id: svn://136.177.114.72/svn_GW/IPhreeqc/trunk@4251 1feff8c3-07ed-0310-ac33-dd36852eb9cd
This commit is contained in:
Scott R Charlton 2010-04-14 04:10:37 +00:00
commit 5c22665a1f
22 changed files with 2377 additions and 2088 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
CVar.hxx
View File

@ -1,8 +1,6 @@
#ifndef __CVAR_HXX_INC
#define __CVAR_HXX_INC
#ifndef INC_CVAR_HXX
#define INC_CVAR_HXX
#include "Debug.h" // ASSERT
#include "Var.h"
#include <ostream> // std::ostream
@ -93,7 +91,6 @@ public:
VRESULT InternalClear()
{
VRESULT vr = Clear();
ASSERT(vr == VR_OK);
if (vr != VR_OK)
{
type = TT_ERROR;
@ -162,4 +159,4 @@ inline std::ostream& operator<< (std::ostream &os, const CVar &a)
return os;
}
#endif // __CVAR_HXX_INC
#endif // INC_CVAR_HXX

4
ErrorReporter.hxx
View File

@ -4,9 +4,9 @@
#include <iosfwd> // std::ostream
#include <cstdio> // std::fprintf
#include "phreeqcns.hxx"
class IErrorReporter {
class IErrorReporter
{
public:
virtual size_t AddError(const char* error_msg) = 0;
virtual void Clear(void) = 0;

116
FInterface.for
View File

@ -1,116 +0,0 @@
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION LoadDatabase(FILENAME)
CHARACTER(LEN=*) :: FILENAME
INTEGER(KIND=4) :: LoadDatabase
INTERFACE
FUNCTION FLoadDatabase(FILENAME)
!DEC$ ATTRIBUTES C,REFERENCE::FLoadDatabase
!DEC$ ATTRIBUTES ALIAS:'_LoadDatabaseF'::FLoadDatabase
CHARACTER(LEN=*) :: FILENAME
INTEGER(KIND=4) :: FLoadDatabase
END FUNCTION FLoadDatabase
END INTERFACE
LoadDatabase = FLoadDatabase(FILENAME)
END FUNCTION LoadDatabase
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
SUBROUTINE OutputLastError
INTERFACE
SUBROUTINE FOutputLastError
!DEC$ ATTRIBUTES C,REFERENCE::FOutputLines
!DEC$ ATTRIBUTES ALIAS:'_OutputLastError'::FOutputLastError
END SUBROUTINE FOutputLastError
END INTERFACE
CALL FOutputLastError
END SUBROUTINE OutputLastError
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION AccumulateLine(LINE)
CHARACTER(LEN=*) :: LINE
INTEGER(KIND=4) :: AccumulateLine
INTERFACE
FUNCTION FAccumulate(LINE)
!DEC$ ATTRIBUTES C,REFERENCE::FAccumulate
!DEC$ ATTRIBUTES ALIAS:'_AccumulateLineF'::FAccumulate
CHARACTER(LEN=*) :: LINE
INTEGER(KIND=4) :: FAccumulate
END FUNCTION FAccumulate
END INTERFACE
AccumulateLine = FAccumulate(LINE)
END FUNCTION AccumulateLine
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION Run(OUTPUT_ON, ERROR_ON, LOG_ON, SELECTED_ON)
LOGICAL(KIND=4) :: OUTPUT_ON
LOGICAL(KIND=4) :: ERROR_ON
LOGICAL(KIND=4) :: LOG_ON
LOGICAL(KIND=4) :: SELECTED_ON
INTEGER(KIND=4) :: Run
INTERFACE
FUNCTION FRun(OUTPUT_ON, ERROR_ON, LOG_ON, SELECTED_ON)
!DEC$ ATTRIBUTES C,REFERENCE::FRun
!DEC$ ATTRIBUTES ALIAS:'_RunF'::FRun
LOGICAL(KIND=4) :: OUTPUT_ON
LOGICAL(KIND=4) :: ERROR_ON
LOGICAL(KIND=4) :: LOG_ON
LOGICAL(KIND=4) :: SELECTED_ON
INTEGER(KIND=4) :: FRun
END FUNCTION FRun
END INTERFACE
Run = FRun(OUTPUT_ON, ERROR_ON, LOG_ON, SELECTED_ON)
END FUNCTION Run
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
SUBROUTINE OutputLines
INTERFACE
SUBROUTINE FOutputLines
!DEC$ ATTRIBUTES C,REFERENCE::FOutputLines
!DEC$ ATTRIBUTES ALIAS:'_OutputLines'::FOutputLines
END SUBROUTINE FOutputLines
END INTERFACE
CALL FOutputLines
END SUBROUTINE OutputLines
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetSelectedOutputRowCount
INTEGER(KIND=4) :: GetSelectedOutputRowCount
INTERFACE
FUNCTION FRows
!DEC$ ATTRIBUTES C,REFERENCE::FRows
!DEC$ ATTRIBUTES ALIAS:'_GetSelectedOutputRowCount'::FRows
INTEGER(KIND=4) :: FRows
END FUNCTION FRows
END INTERFACE
GetSelectedOutputRowCount = FRows() - 1
END FUNCTION GetSelectedOutputRowCount
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetSelectedOutputColumnCount
INTEGER(KIND=4) :: GetSelectedOutputColumnCount
INTERFACE
FUNCTION FCols
!DEC$ ATTRIBUTES C,REFERENCE::FCols
!DEC$ ATTRIBUTES ALIAS:'_GetSelectedOutputColumnCount'::FCols
INTEGER(KIND=4) :: FCols
END FUNCTION FCols
END INTERFACE
GetSelectedOutputColumnCount = FCols()
END FUNCTION GetSelectedOutputColumnCount
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetSelectedOutputValue(ROW,COL,VTYPE,DVALUE,SVALUE)
INTEGER(KIND=4) :: ROW
INTEGER(KIND=4) :: COL
INTEGER(KIND=4) :: VTYPE
REAL(KIND=8) :: DVALUE
CHARACTER(LEN=*) :: SVALUE
INTEGER(KIND=4) :: GetSelectedOutputValue
INTEGER(KIND=4) :: adjcol
INTERFACE
FUNCTION Get(ROW,COL,VTYPE,DVALUE,SVALUE)
!DEC$ ATTRIBUTES C,REFERENCE::Get
!DEC$ ATTRIBUTES ALIAS:'_GetSelectedOutputValueF'::Get
INTEGER(KIND=4) :: ROW
INTEGER(KIND=4) :: COL
INTEGER(KIND=4) :: VTYPE
REAL(KIND=8) :: DVALUE
CHARACTER(LEN=*) :: SVALUE
INTEGER(KIND=4) :: Get
END FUNCTION Get
END INTERFACE
adjcol = col - 1
GetSelectedOutputValue = Get(ROW,adjcol,VTYPE,DVALUE,SVALUE)
END FUNCTION GetSelectedOutputValue

1433
IPhreeqc.cpp
View File

File diff suppressed because it is too large Load Diff

313
IPhreeqcF.F
View File

@ -1,194 +1,217 @@
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION LoadDatabase(FILENAME)
FUNCTION CreateIPhreeqc()
IMPLICIT NONE
INTEGER :: CreateIPhreeqc
INTEGER :: CreateIPhreeqcF
CreateIPhreeqc = CreateIPhreeqcF()
END FUNCTION CreateIPhreeqc
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION LoadDatabase(ID,FILENAME)
IMPLICIT NONE
INTEGER :: ID
CHARACTER(LEN=*) :: FILENAME
INTEGER :: LoadDatabase
#if defined(_WIN32)
INTERFACE
FUNCTION LoadDatabaseF(FILENAME)
!DEC$ ATTRIBUTES C,REFERENCE::LoadDatabaseF
!DEC$ ATTRIBUTES ALIAS:'_LoadDatabaseF'::LoadDatabaseF
CHARACTER(LEN=*) :: FILENAME
INTEGER(KIND=4) :: LoadDatabaseF
END FUNCTION LoadDatabaseF
END INTERFACE
#else
INTEGER :: LoadDatabaseF
#endif
LoadDatabase = LoadDatabaseF(FILENAME)
LoadDatabase = LoadDatabaseF(ID,FILENAME)
END FUNCTION LoadDatabase
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
SUBROUTINE OutputLastError
FUNCTION LoadDatabaseString(ID,INPUT)
IMPLICIT NONE
#if defined(_WIN32)
INTERFACE
SUBROUTINE OutputLastErrorF
!DEC$ ATTRIBUTES C,REFERENCE::OutputLastErrorF
!DEC$ ATTRIBUTES ALIAS:'_OutputLastError'::OutputLastErrorF
END SUBROUTINE OutputLastErrorF
END INTERFACE
#endif
CALL OutputLastErrorF
END SUBROUTINE OutputLastError
INTEGER :: ID
CHARACTER(LEN=*) :: INPUT
INTEGER :: LoadDatabaseString
INTEGER :: LoadDatabaseStringF
LoadDatabaseString = LoadDatabaseStringF(ID,INPUT)
END FUNCTION LoadDatabaseString
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION AccumulateLine(LINE)
FUNCTION AccumulateLine(ID,LINE)
IMPLICIT NONE
INTEGER :: ID
CHARACTER(LEN=*) :: LINE
INTEGER :: AccumulateLine
#if defined(_WIN32)
INTERFACE
FUNCTION AccumulateLineF(LINE)
!DEC$ ATTRIBUTES C,REFERENCE::AccumulateLineF
!DEC$ ATTRIBUTES ALIAS:'_AccumulateLineF'::AccumulateLineF
CHARACTER(LEN=*) :: LINE
INTEGER(KIND=4) :: AccumulateLineF
END FUNCTION AccumulateLineF
END INTERFACE
#else
INTEGER :: AccumulateLineF
#endif
AccumulateLine = AccumulateLineF(LINE)
AccumulateLine = AccumulateLineF(ID,LINE)
END FUNCTION AccumulateLine
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION Run(OUTPUT_ON, ERROR_ON, LOG_ON, SELECTED_ON)
FUNCTION SetSelectedOutputOn(ID,SELECTED_ON)
IMPLICIT NONE
LOGICAL :: OUTPUT_ON
LOGICAL :: ERROR_ON
LOGICAL :: LOG_ON
INTEGER :: ID
LOGICAL :: SELECTED_ON
INTEGER :: Run
#if defined(_WIN32)
INTERFACE
FUNCTION RunF(OUTPUT_ON, ERROR_ON, LOG_ON, SELECTED_ON)
!DEC$ ATTRIBUTES C,REFERENCE::RunF
!DEC$ ATTRIBUTES ALIAS:'_RunF'::RunF
LOGICAL(KIND=4) :: OUTPUT_ON
LOGICAL(KIND=4) :: ERROR_ON
LOGICAL(KIND=4) :: LOG_ON
LOGICAL(KIND=4) :: SELECTED_ON
INTEGER(KIND=4) :: RunF
END FUNCTION RunF
END INTERFACE
#else
INTEGER :: RunF
#endif
Run = RunF(OUTPUT_ON, ERROR_ON, LOG_ON, SELECTED_ON)
END FUNCTION Run
INTEGER :: SetSelectedOutputOn
INTEGER :: SetSelectedOutputOnF
SetSelectedOutputOn = SetSelectedOutputOnF(ID,SELECTED_ON)
END FUNCTION SetSelectedOutputOn
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION RunFile(FILENAME,OUTPUT_ON,ERROR_ON,LOG_ON,SELECTED_ON)
FUNCTION SetOutputOn(ID,OUTPUT_ON)
IMPLICIT NONE
CHARACTER(LEN=*) :: FILENAME
INTEGER :: ID
LOGICAL :: OUTPUT_ON
INTEGER :: SetOutputOn
INTEGER :: SetOutputOnF
SetOutputOn = SetOutputOnF(ID,OUTPUT_ON)
END FUNCTION SetOutputOn
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION SetErrorOn(ID,ERROR_ON)
IMPLICIT NONE
INTEGER :: ID
LOGICAL :: ERROR_ON
INTEGER :: SetErrorOn
INTEGER :: SetErrorOnF
SetErrorOn = SetErrorOnF(ID,ERROR_ON)
END FUNCTION SetErrorOn
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION SetLogOn(ID,LOG_ON)
IMPLICIT NONE
INTEGER :: ID
LOGICAL :: LOG_ON
LOGICAL :: SELECTED_ON
INTEGER :: SetLogOn
INTEGER :: SetLogOnF
SetLogOn = SetLogOnF(ID,LOG_ON)
END FUNCTION SetLogOn
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION SetDumpOn(ID,DUMP_ON)
IMPLICIT NONE
INTEGER :: ID
LOGICAL :: DUMP_ON
INTEGER :: SetDumpOn
INTEGER :: SetDumpOnF
SetDumpOn = SetDumpOnF(ID,DUMP_ON)
END FUNCTION SetDumpOn
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION SetDumpStringOn(ID,DUMP_STRING_ON)
IMPLICIT NONE
INTEGER :: ID
LOGICAL :: DUMP_STRING_ON
INTEGER :: SetDumpStringOn
INTEGER :: SetDumpStringOnF
SetDumpStringOn = SetDumpStringOnF(ID,DUMP_STRING_ON)
END FUNCTION SetDumpStringOn
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetDumpLineCount(ID)
IMPLICIT NONE
INTEGER :: ID
INTEGER :: GetDumpLineCount
INTEGER :: GetDumpLineCountF
GetDumpLineCount = GetDumpLineCountF(ID)
END FUNCTION GetDumpLineCount
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetDumpLine(ID,N,LINE)
IMPLICIT NONE
INTEGER :: ID
INTEGER :: N
CHARACTER(LEN=*) :: LINE
INTEGER :: GetDumpLine
INTEGER :: GetDumpLineF
GetDumpLine = GetDumpLineF(ID,N,LINE)
END FUNCTION GetDumpLine
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetErrorLineCount(ID)
IMPLICIT NONE
INTEGER :: ID
INTEGER :: GetErrorLineCount
INTEGER :: GetErrorLineCountF
GetErrorLineCount = GetErrorLineCountF(ID)
END FUNCTION GetErrorLineCount
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetErrorLine(ID,N,LINE)
IMPLICIT NONE
INTEGER :: ID
INTEGER :: N
CHARACTER(LEN=*) :: LINE
INTEGER :: GetErrorLine
INTEGER :: GetErrorLineF
GetErrorLine = GetErrorLineF(ID,N,LINE)
END FUNCTION GetErrorLine
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetComponentCount(ID)
IMPLICIT NONE
INTEGER :: ID
INTEGER :: GetComponentCount
INTEGER :: GetComponentCountF
GetComponentCount = GetComponentCountF(ID)
END FUNCTION GetComponentCount
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetComponent(ID,N,COMP)
IMPLICIT NONE
INTEGER :: ID
INTEGER :: N
CHARACTER(LEN=*) :: COMP
INTEGER :: GetComponent
INTEGER :: GetComponentF
GetComponent = GetComponentF(ID,N,COMP)
END FUNCTION GetComponent
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION RunAccumulated(ID)
IMPLICIT NONE
INTEGER :: ID
INTEGER :: RunAccumulated
INTEGER :: RunAccumulatedF
RunAccumulated = RunAccumulatedF(ID)
END FUNCTION RunAccumulated
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION RunFile(ID,FILENAME)
IMPLICIT NONE
INTEGER :: ID
CHARACTER(LEN=*) :: FILENAME
INTEGER :: RunFile
#if defined(_WIN32)
INTERFACE
FUNCTION RunFileF(OUT_ON, ERR_ON, LOG_ON, SEL_ON, FILE)
!DEC$ ATTRIBUTES C,REFERENCE::RunFileF
!DEC$ ATTRIBUTES ALIAS:'_RunFileF'::RunFileF
LOGICAL(KIND=4) :: OUT_ON
LOGICAL(KIND=4) :: ERR_ON
LOGICAL(KIND=4) :: LOG_ON
LOGICAL(KIND=4) :: SEL_ON
CHARACTER(LEN=*) :: FILE
INTEGER(KIND=4) :: RunFileF
END FUNCTION RunFileF
END INTERFACE
#else
INTEGER :: RunFileF
#endif
RunFile = RunFileF(OUTPUT_ON, ERROR_ON, LOG_ON,
& SELECTED_ON, FILENAME)
RunFile = RunFileF(ID,FILENAME)
END FUNCTION RunFile
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
SUBROUTINE OutputLines
FUNCTION RunString(ID,INPUT)
IMPLICIT NONE
#if defined(_WIN32)
INTERFACE
SUBROUTINE OutputLinesF
!DEC$ ATTRIBUTES C,REFERENCE::OutputLinesF
!DEC$ ATTRIBUTES ALIAS:'_OutputLines'::OutputLinesF
END SUBROUTINE OutputLinesF
END INTERFACE
#endif
CALL OutputLinesF
END SUBROUTINE OutputLines
INTEGER :: ID
CHARACTER(LEN=*) :: INPUT
INTEGER :: RunString
INTEGER :: RunStringF
RunString = RunStringF(ID,INPUT)
END FUNCTION RunString
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetSelectedOutputRowCount()
FUNCTION GetSelectedOutputRowCount(ID)
IMPLICIT NONE
INTEGER :: ID
INTEGER :: GetSelectedOutputRowCount
#if defined(_WIN32)
INTERFACE
FUNCTION FRows
!DEC$ ATTRIBUTES C,REFERENCE::FRows
!DEC$ ATTRIBUTES ALIAS:'_GetSelectedOutputRowCountF'::FRows
INTEGER(KIND=4) :: FRows
END FUNCTION FRows
END INTERFACE
GetSelectedOutputRowCount = FRows() - 1
#else
INTEGER :: GetSelectedOutputRowCountF
GetSelectedOutputRowCount = GetSelectedOutputRowCountF() - 1
#endif
GetSelectedOutputRowCount = GetSelectedOutputRowCountF(ID)
END FUNCTION GetSelectedOutputRowCount
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetSelectedOutputColumnCount()
FUNCTION GetSelectedOutputColumnCount(ID)
IMPLICIT NONE
INTEGER :: ID
INTEGER :: GetSelectedOutputColumnCount
#if defined(_WIN32)
INTERFACE
FUNCTION FCols
!DEC$ ATTRIBUTES C,REFERENCE::FCols
!DEC$ ATTRIBUTES ALIAS:'_GetSelectedOutputColumnCount'::FCols
INTEGER(KIND=4) :: FCols
END FUNCTION FCols
END INTERFACE
GetSelectedOutputColumnCount = FCols()
#else
INTEGER :: GetSelectedOutputColumnCountF
GetSelectedOutputColumnCount = GetSelectedOutputColumnCountF()
#endif
GetSelectedOutputColumnCount = GetSelectedOutputColumnCountF(ID)
END FUNCTION GetSelectedOutputColumnCount
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION GetSelectedOutputValue(ROW,COL,VTYPE,DVALUE,SVALUE)
FUNCTION GetSelectedOutputValue(ID,ROW,COL,VTYPE,DVALUE,SVALUE)
IMPLICIT NONE
INTEGER :: ID
INTEGER :: ROW
INTEGER :: COL
INTEGER :: VTYPE
REAL*8 :: DVALUE
CHARACTER(LEN=*) :: SVALUE
INTEGER :: GetSelectedOutputValue
INTEGER :: adjcol
#if defined(_WIN32)
INTERFACE
FUNCTION Get(ROW,COL,VTYPE,DVALUE,SVALUE)
!DEC$ ATTRIBUTES C,REFERENCE::Get
!DEC$ ATTRIBUTES ALIAS:'_GetSelectedOutputValueF'::Get
INTEGER(KIND=4) :: ROW
INTEGER(KIND=4) :: COL
INTEGER(KIND=4) :: VTYPE
REAL(KIND=8) :: DVALUE
CHARACTER(LEN=*) :: SVALUE
INTEGER(KIND=4) :: Get
END FUNCTION Get
END INTERFACE
adjcol = col - 1
GetSelectedOutputValue = Get(ROW,adjcol,VTYPE,DVALUE,SVALUE)
#else
INTEGER :: GetSelectedOutputValueF
adjcol = col - 1
GetSelectedOutputValue = GetSelectedOutputValueF(ROW,
& adjcol,VTYPE,DVALUE,SVALUE)
#endif
GetSelectedOutputValue = GetSelectedOutputValueF(ID,ROW,
& COL,VTYPE,DVALUE,SVALUE)
END FUNCTION GetSelectedOutputValue
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
FUNCTION System(COMMAND)
SUBROUTINE OutputLastError
IMPLICIT NONE
CHARACTER(LEN=*) :: COMMAND
INTEGER :: System
INTEGER :: SystemF
System = SystemF(COMMAND)
END FUNCTION System
CALL OutputLastErrorF
END SUBROUTINE OutputLastError
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
SUBROUTINE OutputLines(ID)
IMPLICIT NONE
INTEGER :: ID
CALL OutputLinesF(ID)
END SUBROUTINE OutputLines
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! FUNCTION System(COMMAND)
!! IMPLICIT NONE
!! CHARACTER(LEN=*) :: COMMAND
!! INTEGER :: System
!! INTEGER :: SystemF
!! System = SystemF(COMMAND)
!! END FUNCTION System

588
IPhreeqcLib.cpp Normal file
View File

@ -0,0 +1,588 @@
#include "IPhreeqc.h"
#include "IPhreeqc.hpp"
#include <cassert>
#include <iostream>
class IPhreeqcLib
{
public:
static int CreateIPhreeqc(void);
static IPQ_RESULT DestroyIPhreeqc(int n);
static IPhreeqc* GetInstance(int n);
private:
static std::map<size_t, IPhreeqc*> Instances;
static size_t InstancesIndex;
};
int
CreateIPhreeqc(void)
{
return IPhreeqcLib::CreateIPhreeqc();
}
IPQ_RESULT
DestroyIPhreeqc(int id)
{
return IPhreeqcLib::DestroyIPhreeqc(id);
}
int
LoadDatabase(int id, const char* filename)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->LoadDatabase(filename);
}
return IPQ_BADINSTANCE;
}
int
LoadDatabaseString(int id, const char* input)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->LoadDatabaseString(input);
}
return IPQ_BADINSTANCE;
}
int
UnLoadDatabase(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
IPhreeqcPtr->UnLoadDatabase();
return IPQ_OK;
}
return IPQ_BADINSTANCE;
}
void
OutputLastError(int id)
{
static const char err_msg[] = "OutputLastError: Bad instance.\n";
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
IPhreeqcPtr->OutputLastError();
return;
}
std::cout << err_msg << std::endl;
}
void
OutputLastWarning(int id)
{
static const char err_msg[] = "OutputLastWarning: Bad instance.\n";
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
IPhreeqcPtr->OutputLastWarning();
return;
}
std::cout << err_msg << std::endl;
}
const char*
GetLastErrorString(int id)
{
static const char err_msg[] = "GetLastErrorString: Bad instance.\n";
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->GetLastErrorString();
}
return err_msg;
}
const char*
GetLastWarningString(int id)
{
static const char err_msg[] = "GetLastWarningString: Bad instance.\n";
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->GetLastWarningString();
}
return err_msg;
}
const char*
GetDumpString(int id)
{
static const char empty[] = "";
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->GetDumpString();
}
return empty;
}
int
GetDumpLineCount(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->GetDumpLineCount();
}
return 0;
}
const char*
GetDumpLine(int id, int n)
{
static const char err_msg[] = "GetDumpLine: Bad instance.\n";
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->GetDumpLine(n);
}
return err_msg;
}
int
GetComponentCount(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->ListComponents().size();
}
return 0;
}
const char*
GetComponent(int id, int n)
{
static const char err_msg[] = "GetComponent: Bad instance.\n";
static const char empty[] = "";
static std::string comp;
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
std::list< std::string > comps = IPhreeqcPtr->ListComponents();
if (n < 0 || n >= (int)comps.size())
{
return empty;
}
std::list< std::string >::iterator it = comps.begin();
for(int i = 0; i < n; ++i)
{
++it;
}
comp = (*it);
return comp.c_str();
}
return err_msg;
}
IPQ_RESULT
AccumulateLine(int id, const char *line)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
switch (IPhreeqcPtr->AccumulateLine(line))
{
case VR_OK:
return IPQ_OK;
case VR_OUTOFMEMORY:
return IPQ_OUTOFMEMORY;
default:
assert(false);
}
}
return IPQ_BADINSTANCE;
}
int
GetSelectedOutputOn(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
if (IPhreeqcPtr->GetSelectedOutputOn())
{
return 1;
}
else
{
return 0;
}
}
return IPQ_BADINSTANCE;
}
IPQ_RESULT
SetSelectedOutputOn(int id, int value)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
IPhreeqcPtr->SetSelectedOutputOn(value != 0);
return IPQ_OK;
}
return IPQ_BADINSTANCE;
}
int
GetOutputOn(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
if (IPhreeqcPtr->GetOutputOn())
{
return 1;
}
else
{
return 0;
}
}
return IPQ_BADINSTANCE;
}
IPQ_RESULT
SetOutputOn(int id, int value)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
IPhreeqcPtr->SetOutputOn(value != 0);
return IPQ_OK;
}
return IPQ_BADINSTANCE;
}
int
GetErrorOn(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
if (IPhreeqcPtr->GetErrorOn())
{
return 1;
}
else
{
return 0;
}
}
return IPQ_BADINSTANCE;
}
IPQ_RESULT
SetErrorOn(int id, int value)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
IPhreeqcPtr->SetErrorOn(value != 0);
return IPQ_OK;
}
return IPQ_BADINSTANCE;
}
int
GetLogOn(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
if (IPhreeqcPtr->GetLogOn())
{
return 1;
}
else
{
return 0;
}
}
return IPQ_BADINSTANCE;
}
IPQ_RESULT
SetLogOn(int id, int value)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
IPhreeqcPtr->SetLogOn(value != 0);
return IPQ_OK;
}
return IPQ_BADINSTANCE;
}
int
GetDumpOn(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
if (IPhreeqcPtr->GetDumpOn())
{
return 1;
}
else
{
return 0;
}
}
return IPQ_BADINSTANCE;
}
IPQ_RESULT
SetDumpOn(int id, int value)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
IPhreeqcPtr->SetDumpOn(value != 0);
return IPQ_OK;
}
return IPQ_BADINSTANCE;
}
int
GetDumpStringOn(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
if (IPhreeqcPtr->GetDumpStringOn())
{
return 1;
}
else
{
return 0;
}
}
return IPQ_BADINSTANCE;
}
IPQ_RESULT
SetDumpStringOn(int id, int value)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
IPhreeqcPtr->SetDumpStringOn(value != 0);
return IPQ_OK;
}
return IPQ_BADINSTANCE;
}
int
RunAccumulated(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->RunAccumulated();
}
return IPQ_BADINSTANCE;
}
int
RunFile(int id, const char* filename)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->RunFile(filename);
}
return IPQ_BADINSTANCE;
}
int
RunString(int id, const char* input)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->RunString(input);
}
return IPQ_BADINSTANCE;
}
int
GetSelectedOutputRowCount(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->GetSelectedOutputRowCount();
}
return IPQ_BADINSTANCE;
}
int
GetSelectedOutputColumnCount(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->GetSelectedOutputColumnCount();
}
return IPQ_BADINSTANCE;
}
IPQ_RESULT
GetSelectedOutputValue(int id, int row, int col, VAR* pVAR)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
switch(IPhreeqcPtr->GetSelectedOutputValue(row, col, pVAR))
{
case VR_OK: return IPQ_OK;
case VR_OUTOFMEMORY: return IPQ_OUTOFMEMORY;
case VR_BADVARTYPE: return IPQ_BADVARTYPE;
case VR_INVALIDARG: return IPQ_INVALIDARG;
case VR_INVALIDROW: return IPQ_INVALIDROW;
case VR_INVALIDCOL: return IPQ_INVALIDCOL;
default:
assert(false);
}
}
return IPQ_BADINSTANCE;
}
int
AddError(int id, const char* error_msg)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return (int)IPhreeqcPtr->AddError(error_msg);
}
return IPQ_BADINSTANCE;
}
void
OutputLines(int id)
{
static const char err_msg[] = "OutputLines: Bad instance.\n";
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
IPhreeqcPtr->OutputLines();
return;
}
std::cout << err_msg << std::endl;
}
int
GetErrorLineCount(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return (int)IPhreeqcPtr->GetErrorLineCount();
}
return IPQ_BADINSTANCE;
}
const char*
GetErrorLine(int id, int n)
{
static const char err_msg[] = "GetErrorLine: Bad instance.\n";
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->GetErrorLine(n);
}
return err_msg;
}
int
GetWarningLineCount(int id)
{
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return (int)IPhreeqcPtr->GetWarningLineCount();
}
return IPQ_BADINSTANCE;
}
const char*
GetWarningLine(int id, int n)
{
static const char err_msg[] = "GetWarningLine: Bad instance.\n";
IPhreeqc* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
if (IPhreeqcPtr)
{
return IPhreeqcPtr->GetWarningLine(n);
}
return err_msg;
}
std::map<size_t, IPhreeqc*> IPhreeqcLib::Instances;
size_t IPhreeqcLib::InstancesIndex = 0;
int
IPhreeqcLib::CreateIPhreeqc(void)
{
int n = IPQ_OUTOFMEMORY;
try
{
IPhreeqc* IPhreeqcPtr = new IPhreeqc;
if (IPhreeqcPtr)
{
std::map<size_t, IPhreeqc*>::value_type instance(IPhreeqcLib::InstancesIndex, IPhreeqcPtr);
std::pair<std::map<size_t, IPhreeqc*>::iterator, bool> pr = IPhreeqcLib::Instances.insert(instance);
if (pr.second)
{
n = (int) (*pr.first).first;
++IPhreeqcLib::InstancesIndex;
}
}
}
catch(...)
{
return IPQ_OUTOFMEMORY;
}
return n;
}
IPQ_RESULT
IPhreeqcLib::DestroyIPhreeqc(int id)
{
IPQ_RESULT retval = IPQ_BADINSTANCE;
if (id >= 0)
{
std::map<size_t, IPhreeqc*>::iterator it = IPhreeqcLib::Instances.find(size_t(id));
if (it != IPhreeqcLib::Instances.end())
{
delete (*it).second;
IPhreeqcLib::Instances.erase(it);
retval = IPQ_OK;
}
}
return retval;
}
IPhreeqc*
IPhreeqcLib::GetInstance(int id)
{
std::map<size_t, IPhreeqc*>::iterator it = IPhreeqcLib::Instances.find(size_t(id));
if (it != IPhreeqcLib::Instances.end())
{
return (*it).second;
}
return 0;
}

35
PhreeqcParser.hxx
View File

@ -1,35 +0,0 @@
#if !defined(__PHREEQC_PARSER_HXX_INC)
#define __PHREEQC_PARSER_HXX_INC
// COMMENT: {11/10/2004 10:35:56 PM}#include <string>
// COMMENT: {11/10/2004 10:35:56 PM}//#include <iosfwd>
// COMMENT: {11/10/2004 10:35:56 PM}
// COMMENT: {11/10/2004 10:35:56 PM}
// COMMENT: {11/10/2004 10:35:56 PM}struct PhreeqcStop{};
// COMMENT: {11/10/2004 10:35:56 PM}
// COMMENT: {11/10/2004 10:35:56 PM}
// COMMENT: {11/10/2004 10:35:56 PM}class CPhreeqcParser
// COMMENT: {11/10/2004 10:35:56 PM}{
// COMMENT: {11/10/2004 10:35:56 PM}public:
// COMMENT: {11/10/2004 10:35:56 PM} CPhreeqcParser(std::istream& input);
// COMMENT: {11/10/2004 10:35:56 PM} virtual ~CPhreeqcParser(void);
// COMMENT: {11/10/2004 10:35:56 PM}
// COMMENT: {11/10/2004 10:35:56 PM} // const char* GetErrorMsg(void);
// COMMENT: {11/10/2004 10:35:56 PM}
// COMMENT: {11/10/2004 10:35:56 PM} // overrides
// COMMENT: {11/10/2004 10:35:56 PM} int get_logical_line(int *l);
// COMMENT: {11/10/2004 10:35:56 PM} int get_line(void);
// COMMENT: {11/10/2004 10:35:56 PM} // int error_msg (const char *err_str, const int stop);
// COMMENT: {11/10/2004 10:35:56 PM}
// COMMENT: {11/10/2004 10:35:56 PM}
// COMMENT: {11/10/2004 10:35:56 PM}protected:
// COMMENT: {11/10/2004 10:35:56 PM} std::istream& m_input_stream;
// COMMENT: {11/10/2004 10:35:56 PM} //std::ostream& m_output_stream;
// COMMENT: {11/10/2004 10:35:56 PM} //std::ostream& m_error_stream;
// COMMENT: {11/10/2004 10:35:56 PM}
// COMMENT: {11/10/2004 10:35:56 PM} //std::string m_errors;
// COMMENT: {11/10/2004 10:35:56 PM}};
#endif // __PHREEQC_PARSER_HXX_INC

244
SelectedOutput.cpp
View File

@ -1,241 +1,23 @@
// SelectedOutput.cpp: implementation of the CSelectedOutput class.
//
//////////////////////////////////////////////////////////////////////
#if defined(WIN32)
#include <windows.h> // OutputDebugString
#endif
#if defined(_DEBUG)
#pragma warning(disable : 4786) // disable truncation warning
#include <sstream> // std::ostringstream
#include <windows.h> // ::OutputDebugString
#endif
#include <stdarg.h>
#include <stdio.h>
#include "SelectedOutput.hxx"
#include "phreeqcns.hxx"
#include "Debug.h" // ASSERT
#include "SelectedOutput.hxx" // CSelectedOutput
const size_t RESERVE_ROWS = 80;
const size_t RESERVE_COLS = 80;
int EndRow(void);
void AddSelectedOutput(const char* name, const char* format, va_list argptr);
int warning_msg (const char *err_str);
int EndRow(void)
{
if (CSelectedOutput::Instance()->GetRowCount() <= 1) {
// ensure all user_punch headings are included
for (int i = n_user_punch_index; i < user_punch_count_headings; ++i) {
CSelectedOutput::Instance()->PushBackEmpty(user_punch_headings[i]);
}
}
return CSelectedOutput::Instance()->EndRow();
}
int PushBackDouble(const char* key, double dVal)
{
return CSelectedOutput::Instance()->PushBackDouble(key, dVal);
}
int PushBackLong(const char* key, long lVal)
{
return CSelectedOutput::Instance()->PushBackLong(key, lVal);
}
int PushBackString(const char* key, const char* sVal)
{
return CSelectedOutput::Instance()->PushBackString(key, sVal);
}
int PushBackEmpty(const char* key)
{
return CSelectedOutput::Instance()->PushBackEmpty(key);
}
void AddSelectedOutput(const char* name, const char* format, va_list argptr)
{
int bInt;
int bDouble;
int bString;
int state;
int bLongDouble;
char ch;
/* state values
0 Haven't found start(%)
1 Just read start(%)
2 Just read Flags(-0+ #) (zero or more)
3 Just read Width
4 Just read Precision start (.)
5 Just read Size modifier
6 Just read Type
*/
if (name == NULL) {
return;
}
bDouble = 0;
bInt = 0;
bString = 0;
bLongDouble = 0;
state = 0;
ch = *format++;
while (ch != '\0') {
switch (state) {
case 0: /* looking for Start specification (%) */
switch (ch) {
case '%':
state = 1;
break;
default:
break;
}
ch = *format++;
break;
case 1: /* reading Flags (zero or more(-,+,0,# or space)) */
switch (ch) {
case '-': case '0': case '+': case ' ': case '#':
ch = *format++;
break;
default:
state = 2;
break;
}
break;
case 2: /* reading Minimum field width (decimal integer constant) */
switch (ch) {
case '.':
state = 3;
ch = *format++;
break;
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
ch = *format++;
break;
default:
state = 4;
break;
}
break;
case 3: /* reading Precision specification (period already read) */
switch (ch)
{
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
ch = *format++;
break;
default:
state = 4;
break;
}
break;
case 4: /* reading Size modifier */
switch (ch)
{
case 'l':
ch = *format++;
break;
case 'L':
bLongDouble = 1;
ch = *format++;
break;
case 'h':
ch = *format++;
break;
}
state = 5;
break;
case 5: /* reading Conversion letter */
switch (ch) {
case 'c':
break;
case 'd':
case 'i':
bInt = 1;
break;
case 'n':
case 'o':
case 'p':
break;
case 's':
bString = 1;
break;
case 'u':
case 'x':
case 'X':
case '%':
break;
case 'f':
case 'e':
case 'E':
case 'g':
case 'G':
bDouble = 1;
break;
default:
ASSERT(false);
break;
}
ch = '\0'; /* done */
break;
}
}
if (bDouble) {
double valDouble;
if (bLongDouble) {
valDouble = (double)va_arg(argptr, long double);
}
else {
valDouble = va_arg(argptr, double);
}
CSelectedOutput::Instance()->PushBackDouble(name, valDouble);
}
else if (bInt) {
int valInt;
valInt = va_arg(argptr, int);
CSelectedOutput::Instance()->PushBackLong(name, (long)valInt);
}
else if (bString) {
char* valString;
valString = (char *)va_arg(argptr, char *);
CSelectedOutput::Instance()->PushBackString(name, valString);
}
else {
ASSERT(false);
CSelectedOutput::Instance()->PushBackEmpty(name);
}
}
// COMMENT: {11/16/2004 10:18:22 PM}CSelectedOutput CSelectedOutput::singleton;
CSelectedOutput* CSelectedOutput::s_instance = 0;
CSelectedOutput* CSelectedOutput::Instance()
{
if (s_instance == 0)
{
s_instance = new CSelectedOutput;
}
return s_instance;
}
void CSelectedOutput::Release()
{
if (s_instance)
{
delete s_instance;
s_instance = 0;
}
}
CSelectedOutput::CSelectedOutput()
: m_nRowCount(0)
{
@ -328,9 +110,6 @@ int CSelectedOutput::EndRow(void)
}
}
}
// COMMENT: {11/27/2006 7:22:37 PM}#if defined(_DEBUG)
// COMMENT: {11/27/2006 7:22:37 PM} this->AssertValid();
// COMMENT: {11/27/2006 7:22:37 PM}#endif
return 0;
}
@ -416,7 +195,8 @@ void CSelectedOutput::Dump(const char* heading)
oss << *this;
std::istringstream iss(oss.str());
std::string line;
while (std::getline(iss, line)) {
while (std::getline(iss, line))
{
::OutputDebugStringA(line.c_str());
::OutputDebugStringA("\n");
}
@ -437,13 +217,13 @@ void CSelectedOutput::AssertValid(void)const
std::ostream& operator<< (std::ostream &os, const CSelectedOutput &a)
{
#if defined(_WIN32)
os << "CSelectedOutput(rows=" << a.GetRowCount() << ", cols=" << a.GetColCount() << ")\n";
#endif
CVar v;
for (size_t r = 0; r < a.GetRowCount(); ++r) {
for (size_t c = 0; c < a.GetColCount(); ++c) {
for (size_t r = 0; r < a.GetRowCount(); ++r)
{
for (size_t c = 0; c < a.GetColCount(); ++c)
{
a.Get((int)r, (int)c, &v);
os << v << ", ";
::VarClear(&v);

8
SelectedOutput.hxx
View File

@ -15,18 +15,12 @@
#include <vector>
#include "CVar.hxx"
// TODO: templatize
class CSelectedOutput
{
protected:
CSelectedOutput(void);
public:
static CSelectedOutput* Instance();
static void Release();
CSelectedOutput(void);
virtual ~CSelectedOutput(void);
int EndRow(void);
void Clear(void);

2
Var.c
View File

@ -9,6 +9,8 @@
void VarInit(VAR* pvar)
{
pvar->type = TT_EMPTY;
pvar->sVal = 0;
pvar->vresult = VR_OK;
}
VRESULT VarClear(VAR* pvar)

281
fwrap.c
View File

@ -1,281 +0,0 @@
#include <ctype.h> /* isgraph */
#include <stdlib.h> /* malloc */
#include <memory.h> /* memcpy */
#include <assert.h> /* assert */
#include <stdio.h> /* printf */
#define EXTERNAL extern
#include "phreeqcpp/phreeqc/global.h"
#undef EXTERNAL
struct buffer {
char *name;
struct master *master;
LDBLE moles;
LDBLE gfw;
};
/*
* Routines
*/
extern void add_all_components(void);
extern int build_tally_table(void);
extern int calc_dummy_kinetic_reaction(struct kinetics *kinetics_ptr);
extern int diff_tally_table(void);
extern int elt_list_to_tally_table(struct buffer *buffer_ptr);
extern int entity_exists (char *name, int n_user);
extern int extend_tally_table(void);
extern int free_tally_table(void);
extern int fill_tally_table(int *n_user, int n_buffer);
extern int get_tally_table_rows_columns(int *rows, int *columns);
extern int get_tally_table_column_heading(int column, int *type, char *string);
extern int get_tally_table_row_heading(int column, char *string);
extern int set_reaction_moles(int n_user, LDBLE moles);
extern int store_tally_table(double *array, int row_dim, int col_dim);
extern int warning_msg (const char *err_str);
extern int zero_tally_table(void);
#include "../include/IPhreeqc.h"
/*******************************
When using GNU gcc/g++/g77
compile fortran with:
g77 -fno-second-underscore
********************************/
#if defined(__GNUC__)
#define LoadDatabaseF loaddatabasef_
#define AccumulateLineF accumulatelinef_
#define RunF runf_
#define RunFileF runfilef_
#define GetSelectedOutputValueF getselectedoutputvaluef_
#define OutputLastErrorF outputlasterrorf_
#define OutputLinesF outputlinesf_
#define GetSelectedOutputRowCountF getselectedoutputrowcountf_
#define GetSelectedOutputColumnCountF getselectedoutputcolumncountf_
#define GetSelectedOutputValueF getselectedoutputvaluef_
#define SystemF systemf_
#endif
#include "fwrap.h"
char *
f2cstring(char* fstring, int len)
{
char *cstr, *str;
int i;
str = fstring;
for (i = len - 1; i >= 0 && !isgraph((int)str[i]); i--);
cstr = (char *) malloc((size_t) (i + 2));
if (!cstr) return 0;
cstr[i + 1] = '\0';
memcpy(cstr,str,i+1);
return cstr;
}
void
padfstring(char *dest, char *src, unsigned int len)
{
unsigned int sofar;
for (sofar = 0; (sofar < len) && (*src != '\0'); ++sofar)
*dest++ = *src++;
while (sofar++ < len)
*dest++ = ' ';
}
int
LoadDatabaseF(char* filename, unsigned int filename_length)
{
int n;
char* cfilename;
cfilename = f2cstring(filename, filename_length);
if (!cfilename) {
AddError("LoadDatabase: Out of memory.\n");
return VR_OUTOFMEMORY;
}
n = LoadDatabase(cfilename);
free(cfilename);
return n;
}
VRESULT
AccumulateLineF(char *line, unsigned int line_length)
{
VRESULT n;
char* cline;
cline = f2cstring(line, line_length);
if (!cline) {
AddError("AccumulateLine: Out of memory.\n");
return VR_OUTOFMEMORY;
}
n = AccumulateLine(cline);
free(cline);
return n;
}
int
RunF(int* output_on, int* error_on, int* log_on, int* selected_output_on)
{
return Run(*output_on, *error_on, *log_on, *selected_output_on);
}
int
RunFileF(int* output_on, int* error_on, int* log_on, int* selected_output_on, char* filename, unsigned int filename_length)
{
char* cline;
cline = f2cstring(filename, filename_length);
if (!cline) {
AddError("RunFile: Out of memory.\n");
return (int)VR_OUTOFMEMORY;
}
return RunFile(cline, *output_on, *error_on, *log_on, *selected_output_on);
}
int
GetSelectedOutputRowCountF(void)
{
return GetSelectedOutputRowCount();
}
int
GetSelectedOutputColumnCountF(void)
{
return GetSelectedOutputColumnCount();
}
VRESULT
GetSelectedOutputValueF(int *row, int *col, int *vtype, double* dvalue, char* svalue, unsigned int svalue_length)
{
VRESULT result;
VAR v;
VarInit(&v);
result = GetSelectedOutputValue(*row, *col, &v);
switch (v.type) {
case TT_EMPTY:
*vtype = v.type;
break;
case TT_ERROR:
*vtype = v.type;
break;
case TT_LONG:
*vtype = TT_DOUBLE;
*dvalue = (double)v.lVal;
break;
case TT_DOUBLE:
*vtype = v.type;
*dvalue = v.dVal;
break;
case TT_STRING:
*vtype = v.type;
padfstring(svalue, v.sVal, svalue_length);
break;
default:
assert(0);
}
VarClear(&v);
return result;
}
void
OutputLastErrorF(void)
{
OutputLastError();
}
void
OutputLinesF(void)
{
OutputLines();
}
#if defined(__cplusplus)
extern "C" {
#endif
int
SystemF(char* command, unsigned int command_length)
{
char* cline;
cline = f2cstring(command, command_length);
if (!cline) {
AddError("System: Out of memory.\n");
return (int)VR_OUTOFMEMORY;
}
return system(cline);
}
#if defined(__cplusplus)
}
#endif
#if defined(_WIN32)
#if defined(__cplusplus)
extern "C" {
#endif
//
// Intel Fortran compiler 9.1 /iface:cvf
//
int __stdcall LOADDATABASE(char *filename, unsigned int len)
{
return LoadDatabaseF(filename, len);
}
void __stdcall OUTPUTLASTERROR(void)
{
OutputLastErrorF();
}
int __stdcall ACCUMULATELINE(char *line, unsigned int len)
{
return AccumulateLineF(line, len);
}
int __stdcall RUN(int *output_on, int *error_on, int *log_on, int *selected_on)
{
return RunF(output_on, error_on, log_on, selected_on);
}
int __stdcall RUNFILE(char *filename, unsigned int len, int *output_on, int *error_on, int *log_on, int *selected_on)
{
return RunFileF(output_on, error_on, log_on, selected_on, filename, len);
}
void __stdcall OUTPUTLINES(void)
{
OutputLinesF();
}
int __stdcall GETSELECTEDOUTPUTROWCOUNT(void)
{
return GetSelectedOutputRowCountF() - 1;
}
int __stdcall GETSELECTEDOUTPUTCOLUMNCOUNT(void)
{
return GetSelectedOutputColumnCountF();
}
int __stdcall GETSELECTEDOUTPUTVALUE(int *row, int *col, int *vtype, double* dvalue, char* svalue, unsigned int svalue_length)
{
int adjcol = *col - 1;
return GetSelectedOutputValueF(row, &adjcol, vtype, dvalue, svalue, svalue_length);
}
#if defined(__cplusplus)
}
#endif
#endif

57
fwrap.h
View File

@ -1,28 +1,67 @@
#ifndef __FWRAP__H
#define __FWRAP__H
#if defined(_WINDLL)
#define DLL_EXPORT __declspec(dllexport)
#else
#define DLL_EXPORT
#endif
#if defined(__cplusplus)
extern "C" {
#endif
int CreateIPhreeqcF(void);
int LoadDatabaseF(char* filename, unsigned int filename_length);
int LoadDatabaseF(int *id, char* filename, unsigned int filename_length);
VRESULT AccumulateLineF(char *line, unsigned int line_length);
int LoadDatabaseStringF(int *id, char* input, unsigned int input_length);
int RunF(int* output_on, int* error_on, int* log_on, int* selected_output_on);
IPQ_RESULT AccumulateLineF(int *id, char *line, unsigned int line_length);
int RunFileF(int* output_on, int* error_on, int* log_on, int* selected_output_on, char* filename, unsigned int filename_length);
int GetSelectedOutputRowCountF(void);
int RunAccumulatedF(int *id);
int GetSelectedOutputColumnCountF(void);
int RunFileF(int *id, char* filename, unsigned int filename_length);
VRESULT GetSelectedOutputValueF(int *row, int *col, int *vtype, double* dvalue, char* svalue, unsigned int svalue_length);
int RunStringF(int *id, char* input, unsigned int input_length);
void OutputLastErrorF(void);
int GetSelectedOutputRowCountF(int *id);
void OutputLinesF(void);
int GetSelectedOutputColumnCountF(int *id);
IPQ_RESULT GetSelectedOutputValueF(int *id, int *row, int *col, int *vtype, double* dvalue, char* svalue, unsigned int svalue_length);
IPQ_RESULT SetSelectedOutputOnF(int *id, int* selected_output_on);
IPQ_RESULT SetOutputOnF(int *id, int* output_on);
IPQ_RESULT SetErrorOnF(int *id, int* error_on);
IPQ_RESULT SetLogOnF(int *id, int* log_on);
IPQ_RESULT SetDumpOnF(int *id, int* dump_on);
IPQ_RESULT SetDumpStringOnF(int *id, int* dump_string_on);
int GetDumpLineCountF(int *id);
void GetDumpLineF(int *id, int* n, char* line, unsigned int line_length);
int GetErrorLineCountF(int *id);
void GetErrorLineF(int *id, int* n, char* line, unsigned int line_length);
int GetWarningLineCountF(int *id);
void GetWarningLineF(int *id, int* n, char* line, unsigned int line_length);
int GetComponentCountF(int *id);
void GetComponentF(int *id, int* n, char* line, unsigned int line_length);
void OutputLastErrorF(int *id);
void OutputLinesF(int *id);
#if defined(__cplusplus)

55
fwrap2.c
View File

@ -1,55 +0,0 @@
#include "Var.h"
#include "fwrap.h"
#if defined(_WIN32)
#if defined(__cplusplus)
extern "C" {
#endif
//
// Intel Fortran compiler 9.1 /iface:cvf
//
int LOADDATABASE(char *filename, unsigned int len)
{
return LoadDatabaseF(filename, len);
}
void OUTPUTLASTERROR(void)
{
OutputLastErrorF();
}
int ACCUMULATELINE(char *line, unsigned int len)
{
return AccumulateLineF(line, len);
}
int RUN(int *output_on, int *error_on, int *log_on, int *selected_on)
{
return RunF(output_on, error_on, log_on, selected_on);
}
int RUNFILE(char *filename, unsigned int len, int *output_on, int *error_on, int *log_on, int *selected_on)
{
return RunFileF(output_on, error_on, log_on, selected_on, filename, len);
}
void OUTPUTLINES(void)
{
OutputLinesF();
}
int GETSELECTEDOUTPUTROWCOUNT(void)
{
return GetSelectedOutputRowCountF() - 1;
}
int GETSELECTEDOUTPUTCOLUMNCOUNT(void)
{
return GetSelectedOutputColumnCountF();
}
int GETSELECTEDOUTPUTVALUE(int *row, int *col, int *vtype, double* dvalue, char* svalue, unsigned int svalue_length)
{
int adjcol = *col - 1;
return GetSelectedOutputValueF(row, &adjcol, vtype, dvalue, svalue, svalue_length);
}
#if defined(__cplusplus)
}
#endif
#endif

118
fwrap2.cpp Normal file
View File

@ -0,0 +1,118 @@
#include "IPhreeqc.h"
#include "fwrap.h"
#if defined(_WIN32)
#if defined(__cplusplus)
extern "C" {
#endif
//
// Intel Fortran compiler 9.1 /iface:cvf
//
DLL_EXPORT int CREATEIPHREEQC(void)
{
return CreateIPhreeqcF();
}
DLL_EXPORT int LOADDATABASE(int *id, char *filename, unsigned int len)
{
return LoadDatabaseF(id, filename, len);
}
DLL_EXPORT void OUTPUTLASTERROR(int *id)
{
OutputLastErrorF(id);
}
DLL_EXPORT int ACCUMULATELINE(int *id, char *line, unsigned int len)
{
return AccumulateLineF(id, line, len);
}
DLL_EXPORT void SETSELECTEDOUTPUTON(int *id, int *selected_on)
{
SetSelectedOutputOnF(id, selected_on);
}
DLL_EXPORT void SETOUTPUTON(int *id, int *output_on)
{
SetOutputOnF(id, output_on);
}
DLL_EXPORT void SETERRORON(int *id, int *error_on)
{
SetErrorOnF(id, error_on);
}
DLL_EXPORT void SETLOGON(int *id, int *log_on)
{
SetLogOnF(id, log_on);
}
DLL_EXPORT void SETDUMPON(int *id, int *dump_on)
{
SetDumpOnF(id, dump_on);
}
DLL_EXPORT void SETDUMPSTRINGON(int *id, int *dump_string_on)
{
SetDumpStringOnF(id, dump_string_on);
}
DLL_EXPORT int GETDUMPLINECOUNT(int *id)
{
return GetDumpLineCountF(id);
}
DLL_EXPORT void GETDUMPLINE(int *id, int *n, char* line, unsigned int line_length)
{
GetDumpLineF(id, n, line, line_length);
}
DLL_EXPORT int GETERRORLINECOUNT(int *id)
{
return GetErrorLineCountF(id);
}
DLL_EXPORT void GETERRORLINE(int *id, int *n, char* line, unsigned int line_length)
{
GetErrorLineF(id, n, line, line_length);
}
DLL_EXPORT int GETWARNINGLINECOUNT(int *id)
{
return GetWarningLineCountF(id);
}
DLL_EXPORT void GETWARNINGLINE(int *id, int *n, char* line, unsigned int line_length)
{
GetWarningLineF(id, n, line, line_length);
}
DLL_EXPORT int GETCOMPONENTCOUNT(int *id)
{
return GetComponentCountF(id);
}
DLL_EXPORT void GETCOMPONENT(int *id, int *n, char* line, unsigned int line_length)
{
GetComponentF(id, n, line, line_length);
}
DLL_EXPORT int RUNACCUMULATED(int *id)
{
return RunAccumulatedF(id);
}
DLL_EXPORT int RUNFILE(int *id, char *filename, unsigned int len)
{
return RunFileF(id, filename, len);
}
DLL_EXPORT int RUNSTRING(int *id, char *input, unsigned int len)
{
return RunStringF(id, input, len);
}
DLL_EXPORT void OUTPUTLINES(int *id)
{
OutputLinesF(id);
}
DLL_EXPORT int GETSELECTEDOUTPUTROWCOUNT(int *id)
{
return GetSelectedOutputRowCountF(id);
}
DLL_EXPORT int GETSELECTEDOUTPUTCOLUMNCOUNT(int *id)
{
return GetSelectedOutputColumnCountF(id);
}
DLL_EXPORT int GETSELECTEDOUTPUTVALUE(int *id, int *row, int *col, int *vtype, double* dvalue, char* svalue, unsigned int svalue_length)
{
return GetSelectedOutputValueF(id, row, col, vtype, dvalue, svalue, svalue_length);
}
#if defined(__cplusplus)
}
#endif
#endif

55
fwrap3.c
View File

@ -1,55 +0,0 @@
#include "Var.h"
#include "fwrap.h"
#if defined(_WIN32)
#if defined(__cplusplus)
extern "C" {
#endif
//
// Intel Fortran compiler 9.1 /iface:cref /assume:underscore
//
int loaddatabase_(char *filename, unsigned int len)
{
return LoadDatabaseF(filename, len);
}
void outputlasterror_(void)
{
OutputLastErrorF();
}
int accumulateline_(char *line, unsigned int len)
{
return AccumulateLineF(line, len);
}
int run_(int *output_on, int *error_on, int *log_on, int *selected_on)
{
return RunF(output_on, error_on, log_on, selected_on);
}
int runfile_(char *filename, unsigned int len, int *output_on, int *error_on, int *log_on, int *selected_on)
{
return RunFileF(output_on, error_on, log_on, selected_on, filename, len);
}
void outputlines_(void)
{
OutputLinesF();
}
int getselectedoutputrowcount_(void)
{
return GetSelectedOutputRowCountF() - 1;
}
int getselectedoutputcolumncount_(void)
{
return GetSelectedOutputColumnCountF();
}
int getselectedoutputvalue_(int *row, int *col, int *vtype, double* dvalue, char* svalue, unsigned int svalue_length)
{
int adjcol = *col - 1;
return GetSelectedOutputValueF(row, &adjcol, vtype, dvalue, svalue, svalue_length);
}
#if defined(__cplusplus)
}
#endif
#endif

118
fwrap3.cpp Normal file
View File

@ -0,0 +1,118 @@
#include "IPhreeqc.h"
#include "fwrap.h"
#if defined(_WIN32)
#if defined(__cplusplus)
extern "C" {
#endif
//
// Intel Fortran compiler 9.1 /iface:cref /assume:underscore
//
DLL_EXPORT int createiphreeqc_(void)
{
return CreateIPhreeqcF();
}
DLL_EXPORT int loaddatabase_(int *id, char *filename, unsigned int len)
{
return LoadDatabaseF(id, filename, len);
}
DLL_EXPORT void outputlasterror_(int *id)
{
OutputLastErrorF(id);
}
DLL_EXPORT int accumulateline_(int *id, char *line, unsigned int len)
{
return AccumulateLineF(id, line, len);
}
DLL_EXPORT void setselectedoutputon_(int *id, int *selected_on)
{
SetSelectedOutputOnF(id, selected_on);
}
DLL_EXPORT void setoutputon_(int *id, int *output_on)
{
SetOutputOnF(id, output_on);
}
DLL_EXPORT void seterroron_(int *id, int *error_on)
{
SetErrorOnF(id, error_on);
}
DLL_EXPORT void setlogon_(int *id, int *log_on)
{
SetLogOnF(id, log_on);
}
DLL_EXPORT void setdumpon_(int *id, int *dump_on)
{
SetLogOnF(id, dump_on);
}
DLL_EXPORT void setdumpstringon_(int *id, int *dump_string_on)
{
SetDumpStringOnF(id, dump_string_on);
}
DLL_EXPORT int getdumplinecount_(int *id)
{
return GetDumpLineCountF(id);
}
DLL_EXPORT void getdumpline_(int *id, int *n, char* line, unsigned int line_length)
{
GetDumpLineF(id, n, line, line_length);
}
DLL_EXPORT int geterrorlinecount_(int *id)
{
return GetErrorLineCountF(id);
}
DLL_EXPORT void geterrorline_(int *id, int *n, char* line, unsigned int line_length)
{
GetErrorLineF(id, n, line, line_length);
}
DLL_EXPORT int getwarninglinecount_(int *id)
{
return GetWarningLineCountF(id);
}
DLL_EXPORT void getwarningline_(int *id, int *n, char* line, unsigned int line_length)
{
GetWarningLineF(id, n, line, line_length);
}
DLL_EXPORT int getcomponentcount_(int *id)
{
return GetComponentCountF(id);
}
DLL_EXPORT void getcomponent_(int *id, int *n, char* line, unsigned int line_length)
{
GetComponentF(id, n, line, line_length);
}
DLL_EXPORT int runaccumulated_(int *id)
{
return RunAccumulatedF(id);
}
DLL_EXPORT int runfile_(int *id, char *filename, unsigned int len)
{
return RunFileF(id, filename, len);
}
DLL_EXPORT int runstring_(int *id, char *input, unsigned int len)
{
return RunStringF(id, input, len);
}
DLL_EXPORT void outputlines_(int *id)
{
OutputLinesF(id);
}
DLL_EXPORT int getselectedoutputrowcount_(int *id)
{
return GetSelectedOutputRowCountF(id);
}
DLL_EXPORT int getselectedoutputcolumncount_(int *id)
{
return GetSelectedOutputColumnCountF(id);
}
DLL_EXPORT int getselectedoutputvalue_(int *id, int *row, int *col, int *vtype, double* dvalue, char* svalue, unsigned int svalue_length)
{
return GetSelectedOutputValueF(id, row, col, vtype, dvalue, svalue, svalue_length);
}
#if defined(__cplusplus)
}
#endif
#endif

5
global.c
View File

@ -1,5 +0,0 @@
#define EXTERNAL
#define MAIN
// TEST RMWEBB WRITE ACCESS
#include "global.h"
#include "phqalloc.h"

89
module_files.c
View File

@ -1,89 +0,0 @@
#include "module_files.h"
#if defined(R_SO)
#include "phreeqc_files.inl"
#else
#include "phreeqcpp/phreeqc/phreeqc_files.c"
#endif
static int module_isopen_handler(const int type);
static int module_open_handler(const int type, const char *file_name);
int
module_handler(const int action, const int type, const char *err_str, const int stop, void *cookie, const char *format, va_list args)
{
switch (action) {
case ACTION_OPEN:
return module_open_handler(type, err_str);
break;
case ACTION_ISOPEN:
return module_isopen_handler(type);
break;
default:
return phreeqc_handler(action, type, err_str, stop, cookie, format, args);
break;
}
return ERROR;
}
static int
module_isopen_handler(const int type)
{
switch (type)
{
case OUTPUT_PUNCH:
if (punch_file) return 1;
break;
default:
assert(0);
}
return 0;
}
static int
module_open_handler(const int type, const char *file_name)
{
assert(file_name && strlen(file_name));
switch (type)
{
case OUTPUT_MESSAGE:
if (output != NULL)
{
fclose(output);
output = NULL;
}
if ( (output = fopen(file_name, "w")) == NULL)
{
return ERROR;
}
break;
case OUTPUT_ERROR:
assert(error_file != stderr);
if (error_file != NULL)
{
fclose(error_file);
error_file = NULL;
}
if ( (error_file = fopen(file_name, "w")) == NULL)
{
return ERROR;
}
break;
case OUTPUT_LOG:
if (log_file != NULL)
{
fclose(log_file);
log_file = NULL;
}
if ( (log_file = fopen(file_name, "w")) == NULL)
{
return ERROR;
}
break;
default:
return open_handler(type, file_name);
break;
}
return(OK);
}

25
module_files.h
View File

@ -1,25 +0,0 @@
#ifndef __MODULE_FILES__H
#define __MODULE_FILES__H
#include <stdio.h>
#include <stdarg.h>
#if defined(__cplusplus)
extern "C" {
#endif
int module_handler(const int action, const int type, const char *err_str, const int stop, void *cookie, const char *format, va_list args);
int output_isopen(const int type);
typedef enum {
ACTION_ISOPEN = -100,
} module_action_type;
#if defined(__cplusplus)
}
#endif
#endif /* __MODULE_FILES__H */

21
module_output.c
View File

@ -1,21 +0,0 @@
#include "module_files.h"
#if defined(R_SO)
#include "output.inl"
#else
#include "phreeqcpp/phreeqc/output.c"
#endif
/* ---------------------------------------------------------------------- */
int output_isopen(const int type)
/* ---------------------------------------------------------------------- */
{
size_t i;
int isopen;
for (i = 0; i < count_output_callback; ++i) {
isopen = (output_callbacks[i].callback)(ACTION_ISOPEN, type, NULL, CONTINUE, output_callbacks[i].cookie, NULL, NULL);
if (isopen) return 1;
}
return 0;
}

27
phreeqcns.hxx
View File

@ -1,27 +0,0 @@
// phreeqc namespace
//
#if !defined(_INC_GLOBALNS)
#define _INC_GLOBALNS
#if defined(_DEBUG)
#pragma warning(disable : 4786) // disable truncation warning
#endif
#include <math.h>
#define EXTERNAL extern
#include "global.h"
#include "phqalloc.h"
#include "input.h"
#include "output.h"
#include "phrqproto.h"
EXTERNAL int n_user_punch_index;
#undef EXTERNAL
#endif /* _INC_GLOBALNS */

8
pp_sys.c → pp_sys.cpp
View File

@ -6,7 +6,7 @@
#include <string.h> /* strlen */
extern char *f2cstring(char* fstring, int len);
extern void padfstring(char *dest, char *src, unsigned int len);
extern void padfstring(char *dest, const char *src, unsigned int len);
#define fullpathpp fullpathpp_
#define splitpathpp splitpathpp_
@ -63,8 +63,8 @@ splitpathpp(char *path, char* drive, char* dir, char* name, char* ext,
unsigned int ext_len)
{
int i;
int dot = 0;
int slash = 0;
size_t dot = 0;
size_t slash = 0;
int slash_found = 0;
char *cpath = NULL;
size_t plen = 0;
@ -72,7 +72,7 @@ splitpathpp(char *path, char* drive, char* dir, char* name, char* ext,
/* linux has no drives */
padfstring(drive, "", drive_len);
if (cpath = f2cstring(path, path_len)) {
if ((cpath = f2cstring(path, path_len))) {
plen = strlen(cpath);
}