//###
//*****************************************************************************
//                                                                            *
//     Program Name: therm                                                    *
//                                                                            *
//     File Name: therm.cpp                                                   *
//                                                                            *
//     Purpose:  This is the start of the Thermodynamic Equilibrium           *
//               Program                                                      *
//                                                                            *
//     Author:    Robert L. Reese                                             *
//                                                                            *
//     Date:      June 1, 1973                                                *
//                                                                            *
//     Language: Borland C++ Compiler, Version 4.5                            *
//                                                                            *
//     Hardware: IBM Compatible PC                                            *
//                                                                            *
//     Operating System: Microsoft Windows 98                                 *
//                                                                            *
//     Update History:                                                        *
//                                                                            *
//     Name          Date        Revision        Changes                      *
//     ----          ----        ---------        -------                     *
//                                                                            *
//    R.L. Reese     06/01/73        0           Initial Release              *
//    R.L. Reese     11/23/03        A           Converted to C++             *
//    R.L. Reese     04/12/06        B           Added new_thermo parameter   *
//                                               for inputing type of thermo  *
//                                               file                         *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//  Execution Command:                                                        *
//                                                                            *
//  therm Where:                                                              *
//                                                                            *
//     No Parameters                                                          *
//                                                                            *
//     Program will request name of input parameter file and output           *
//     listing file.  The program will expect the thermodynamic data          *
//     file to be named THERMODAT                                             *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//     Definitions:                                                           *
//                                                                            *
//     Local Variables:                                                       *
//     ---------------                                                        *
//                                                                            *
//     adata          - Character buffer containing data returned from        *
//                      init_read                                             *
//     break_flag     - Logical flag indicating if error occurred in          *
//                      function file_open                                    *
//     break_value    - Integer value indicating if break from loop is        *
//                      required upon return from a function                  *
//     eof            - Integer value of status returned from init_read       *
//     empty_file     - Integer value of status returned from init_read       *
//     file_error_inp - Logical flag indicating if error on input file        *
//                      open                                                  *
//     file_error_out - Logical flag indicating if error on output file       *
//                      open                                                  *
//     file_error_scr - Logical flag indicating if error on scratch file      *
//                      open                                                  *
//     file_error_thr - Logical flag indicating if error on thermo file       *
//                      open                                                  *
//     first_time     - Logical flag indicating if first time through         *
//                      outer loop                                            *
//     i              - Integer for loop index                                *
//     j              - Integer for loop index                                *
//     k              - Integer for loop index                                *
//     nbytes         - Integer value of number of bytes from init_read       *
//     read_status    - Integer status of read operation                      *
//     stop_or_go     - Integer value input by user to stop or go             *
//                                                                            *
//     Pointers:                                                              *
//     --------                                                               *
//                                                                            *
//     adata_pt       - Character pointer to data from init_read              *
//     break_value    - Integer pointer to value indicating if error          *
//                      occurred in called function                           *
//     empty_file_pt  - Integer pointer to empty file value from              *
//                      init_read                                             *
//     eof_pt         - Integer pointer to eof value from init_read           *
//     nbytes_pt      - Integer pointer to number of bytes read from          *
//                      init_read                                             *
//     read_status_pt - Integer pointer to current read status                *
//                                                                            *
//     Global Variables:                                                      *
//     ----------------                                                       *
//                                                                            *
//     local(extern.h)                                                        *
//     aa             - Double precision array used to store increment        *
//                      value of reactant mole fraction                       *
//     bb             - Real array used to store base value of reactant       *
//                      mole fraction                                         *
//     fco            - Real value of fugacity of CO                          *
//     fco2           - Real value of fugacity of CO2                         *
//     fh2            - Real value of fugacity of H2                          *
//     fh2o           - Real value of fugacity of H2O                         *
//     ll             - Integer variable used to determine what reactants     *
//                      are to be added or removed                            *
//     removed        - Integer variable used to determine if the first       *
//                      reactant in a ternary system is to be removed         *
//     to             - Real array used to store final value of reactant      *
//                      mole fraction                                         *
//     local - used by therm and loop_read                                    *
//     pressure_index - Integer do loop index for processing pressure         *
//                      inputs                                                *
//     processed_react- Logical flag indicating if the react records          *
//                      have been read                                        *
//     read_error     - Logical flag indicating if read error occurred        *
//     read_loop      - Logical flag controlling the read loop                *
//     temp_index     - Integer do loop index for processing temperature      *
//                      inputs                                                *
//     indx.h                                                                 *
//     alter          - Logical variable used to indicate reactant mole       *
//                      mole fractions with unequal top and base values       *
//                      are to be altered                                     *
//     newmol         - Integer value used in react to determine if           *
//                      reactant records have been read                       *
//     nomit          - Integer value of number of species to be omitted      *
//     plus           - Logical variable used to indicate if reactants        *
//                      are to be added to the system or if a ternary         *
//                      system is being considered                            *
//     systm          - Logical variable used to denote that a ternary        *
//                      system is being considered                            *
//     misc.h                                                                 *
//     noconv         - Integer value of accumulative number of times         *
//                      there is to no solution to a T-P point                *
//     points.h                                                               *
//     gas_input      - Logical variable used to determine if gas is used     *
//     rsize          - Real value used to determine size of mole fraction    *
//                      values for gas specie to be output                    *
//     tem            - Logical variable used to denote that for each         *
//                      assigned T there is an assigned P                     *
//     speces.h                                                               *
//     ensert         - Character*4 variable containing ith specie of n       *
//                      species which are specified to be considered or       *
//                      input                                                 *
//     omit           - Character*4 variable containing ith specie of n       *
//                      to be omitted from current system                     *
//                                                                            *
//     Constants:                                                             *
//     ---------                                                              *
//                                                                            *
//     local                                                                  *
//     FALSE          - Defines value of logical false = 0                    *
//     TRUE           - Defines value of logical true = 1                     *
//     arrays.h                                                               *
//     adata_len      - Integer value for length of adata buffer              *
//     element_max    - Integer containing maximum number of elements allowed *
//     size_char      - Integer value used as len of char to replace default  *
//                      length of 4 characters in one word for FORTRAN 4 and  *
//                      FORTRAN 77 conversion                                 *
//     species_max    - Integer value of maximum number of species allowed    *
//     stop_or_go_len - Integer value of length of stop_or_go character       *
//     sub_size       - Integer variable used as size of species name segment *
//     total_char     - Integer value of length of species character names    *
//     constant.h                                                             *
//     iblank         - Character*1 containing a blank                        *
//                                                                            *
//     Include Files:                                                         *
//     --------------                                                         *
//                                                                            *
//     arrays.h       - Contains sizes for include files                      *
//     constant.h     - Contains constants and sizes                          *
//     double.h       - Contains double precision variables                   *
//                      (externals here)                                      *
//     extern.h       - Contains all variables used as externals in           *
//                      the other functions used by therm                     *
//     indx.h         - Contains index variables (externals here)             *
//     iostream.h     - Contains C++ I/O routines                             *
//     misc.h         - Contains miscellaneous variables (externals           *
//                      here)                                                 *
//     points.h       - Contains temperature and pressure variables           *
//                      (externals here)                                      *
//     speces.h       - Contains species variables (externals here)           *
//     stdio.h        - Contains C++ I/O routines                             *
//     stdlib.h       - Contains C++ standard library routines                *
//     string.h       - Contains C++ string routines                          *
//                                                                            *
//     External Software:                                                     *
//     -----------------                                                      *
//                                                                            *
//     extern_init    - Routine to initialize all variables in include files  *
//     file_open      - Routine to open input and output files                *
//     loop_read      - Routine to read and process input records             *
//                                                                            *
//     Files:                                                                 *
//     -----                                                                  *
//                                                                            *
//       Input Files:                                                         *
//                                                                            *
//       infile       - Input parameter file - FILE *input_unit               *
//       'THERMODAT'  - Input thermodynamic data file- FILE *thermo_unit      *
//                                                                            *
//       Intermediate Files:                                                  *
//                                                                            *
//       'SCRATCH'    - Temporary file for storing thermodynamic data         *
//                      FILE * scratch_unit                                   *
//                                                                            *
//       Output Files:                                                        *
//                                                                            *
//       outfile      - Output listing file - FILE * output_unit              *
//                                                                            *
//*****************************************************************************
//###
 
#include "arrays.h"
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define FALSE 0
#define TRUE  1
 
void extern_init(void);
 
void file_open(int *break_flag_pt,
              int *file_error_inp_pt,
              int *file_error_out_pt,
              int *file_error_scr_pt,
              int *file_error_thr_pt);
 
void loop_read(FILE *input_unit,
               FILE *output_unit,
               FILE *scratch_unit,
               FILE *therm_unit,
               int   *read_status_pt,
               int   *eof_pt,
               char  *adata_pt,
               int   *empty_file_pt,
               int   *nbytes_pt,
               int   *break_value_pt);
 
FILE *input_unit;
FILE *output_unit;
FILE *scratch_unit;
FILE *therm_unit;
 
// extern.h contains all variables used as externals in the other functions
 
#include "extern.h"
 
//  externals for function loop_read
 
int pressure_index ;
int processed_react ;
int read_error;
int read_loop ;
int temp_index ;
 
int main(void)
{
 
#include "constant.h"
 
  int break_flag;
  int break_value;
  int eof;
  int empty_file;
  int file_error_inp ;
  int file_error_out ;
  int file_error_scr ;
  int file_error_thr ;
  int i ;
  int j ;
  int k ;
  int nbytes;
  int read_status ;
 
//  pointers
 
  char *adata_pt;
  int  *break_value_pt;
  int  *empty_file_pt;
  int  *eof_pt;
  int  *nbytes_pt;
  int  *read_status_pt;
 
  char  adata[adata_len];
  char  stop_or_go[stop_or_go_len] ;
 
  static int first_time = TRUE ;
 
//  initialize pointers
 
  adata_pt       = &adata[0];
  break_value_pt = &break_value;
  empty_file_pt  = &empty_file;
  eof_pt         = &eof;
  nbytes_pt      = &nbytes;
  read_status_pt = &read_status;
 
//start outer_loop
  for (;;)
  {
    extern_init();
 
    read_error = FALSE;
//  start first_test
    if(! first_time)
    {
      cout << " TYPE 1 TO CONTINUE, ZERO TO STOP : " ;
      cin >> stop_or_go ;
//    start all_done
      if(stop_or_go[0] == '0')
      {
//      exit outer_loop
        break;
      }
      else if(stop_or_go[0] != '1')
      {
//      exit outer_loop
        read_error = TRUE;
        cout << " Input error! "<<endl;
        break;
      } // end all_done
      fclose(scratch_unit) ;
      fclose(therm_unit) ;
      fclose(input_unit) ;
      fclose(output_unit) ;
    }
    else
    {
      first_time = FALSE ;
    } // end first_test
 
// Call file_open to open files and check their status
 
    file_open(&break_flag,
              &file_error_inp,
              &file_error_out,
              &file_error_scr,
              &file_error_thr);
 
//  start file_error
    if(break_flag)
    {
//      exit outer_loop
      break;
    } // end file_error
 
//  initialize global variables
 
    newmol           = 0 ;
    noconv           = 0 ;
    tem              = FALSE ;
    alter            = FALSE ;
    systm            = FALSE ;
    plus             = FALSE ;
    gas_input        = FALSE ;
    new_thermo       = FALSE ;
    processed_react  = FALSE ;
    rsize            = 0.0 ;
    nomit            = 0 ;
    *read_status_pt  = 0 ;
 
//     Initialize character arrays
 
//  start init_llmt1
    for(i=0;i<element_max;i++)
    {
//    start init_llmt2
      for(j=0;j<size_char;j++)
      {
        llmt[j][i] = iblank;
      } // end init_llmt2
    } // end init_llmt1
 
//  start omit_ensert1
    for(i=0;i<species_max;i++)
    {
//    start omit_ensert2
      for(j=0;j<total_char;j++)
      {
        ensert[j][i] = iblank;
        omit[j][i]   = iblank;
      } // end omit_ensert2
    } // end omit_ensert1
 
//  start init_sub1
    for(i=0;i<species_max;i++)
    {
//    start init_sub2
      for(j=0;j<sub_size;j++)
      {
//      start init_sub3
        for(k=0;k<size_char;k++)
        {
          sub[k][j][i] = iblank;
        } // end init_sub3
      } // end init_sub2
    } // end init_sub1
 
//     Read and write code records.
 
    loop_read(input_unit,
              output_unit,
              scratch_unit,
              therm_unit,
              read_status_pt,
              eof_pt,
              adata_pt,
              empty_file_pt,
              nbytes_pt,
              break_value_pt);
 
//  start check_status
    if(*read_status_pt !=0)
    {
      file_error_inp = TRUE ;
      file_error_thr = TRUE ;
//    exit outer_loop
      break ;
    } // end check_status
//  start read_error_check
    if(read_error)
    {
//    exit outer_loop
      break;
    } // end read_error_check
  } // end outer_loop
 
//start close_test
  if( ! first_time)
  {
//  start scratch_error
    if( ! file_error_scr)
    {
      fclose(scratch_unit) ;
    } // end scratch_error
//  start therm_error
    if( !file_error_thr)
    {
      fclose(therm_unit) ;
    } // end therm_error
//  start input_error
    if( !file_error_inp)
    {
      fclose(input_unit) ;
    } // end input_error
//  start output_error
    if( !file_error_out)
    {
      fclose(output_unit) ;
    } // end output_error
  } // end close_test
// start  final_test
  if((! file_error_inp) &&
     (! file_error_out) &&
     (! file_error_thr) &&
     (! file_error_scr) &&
     (! read_error))
  {
    cout << " CONGRATULATIONS! The program has ended normally. "<<endl ;
  }
  else
  {
    cout << " SORRY! The program has ended abnormally. "<<endl ;
  } // end final_test
 
  exit(0);
 
} // end program therm
//###
//*****************************************************************************
//                                                                            *
//     Function Name: arrays_clear                                            *
//                                                                            *
//     File Name: arrays_clear.cpp                                            *
//                                                                            *
//     Purpose:  Function called from search to intialize arrays to zeros     *
//               and blanks.                                                  *
//                                                                            *
//     Author:    Robert L. Reese                                             *
//                                                                            *
//     Date: January 28, 2004                                                 *
//                                                                            *
//     Language: Borland C++ Compiler, Version 4.5                            *
//                                                                            *
//     Hardware: IBM Compatible PC                                            *
//                                                                            *
//     Operating System: Microsoft Windows 98                                 *
//                                                                            *
//     Update History:                                                        *
//                                                                            *
//     Name        Date      Revision          Changes                        *
//     ----        ----      ---------         -------                        *
//                                                                            *
//    R.L. Reese   01/28/04      0             Initial Release                *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//  Usage:                                                                    *
//                                                                            *
//     arrays_clear(blank) where:                                             *
//                                                                            *
//     blank        - Character pointer to array containing blanks            *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//     Definitions:                                                           *
//                                                                            *
//     Local Variables:                                                       *
//     ----------------                                                       *
//                                                                            *
//     i              - Integer value used as do loop index                   *
//     j              - Integer value used as do loop index                   *
//                                                                            *
//     Pointers                                                               *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Global Variables:                                                      *
//     -----------------                                                      *
//                                                                            *
//     Used by search and search_coeff                                        *
//     b              - Real array containing stoichiometric coefficients of  *
//                      ith element read from the coefficient records         *
//     insert_flag    - Integer array used to flag legal insert species       *
//     lmt            - Character*4 array used as alphanumeric storage for the*
//                      name of elements to be put into temporary storage in  *
//                      systm and plus problems                               *
//     mt             - Character*4 array used as alphanumeric symbol of the  *
//                      elemen read from the coefficient records              *
//     nam            - Character*4 array used as alphanumeric symbol of      *
//                      species name read from the coefficient records        *
//     omit_flag      - Integer array used to flag legal omit species         *
//                                                                            *
//     Constants:                                                             *
//     ---------                                                              *
//                                                                            *
//     arrays.h                                                               *
//     b_size          - Integer variable used as size of b array             *
//     blank_size      - Integer value of size of blank array                 *
//     element_max     - Integer containing maximum number of elements allowed*
//     lmt_size        - Integer variable used as size of lmt array           *
//     mt_size         - Integer variable used as size of mt array            *
//     size_char       - Integer value used as len of char to replace default *
//                       length of 4 characters in one word for FORTRAN 4 and *
//                       FORTRAN 77 conversion                                *
//     species_max     - Integer value of maximum number of species allowed   *
//     sub_size        - Integer variable used as size of species name segment*
//                                                                            *
//     Include Files:                                                         *
//     -------------                                                          *
//                                                                            *
//     arrays.h        - Contains array sizes                                 *
//                                                                            *
//     External Software:                                                     *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Files:                                                                 *
//     -----                                                                  *
//                                                                            *
//       Input Files:                                                         *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Intermediate Files:                                                  *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Output Files:                                                        *
//                                                                            *
//       None                                                                 *
//                                                                            *
//*****************************************************************************
//###
 
#include "arrays.h"
 
extern float b[b_size] ;
 
extern int   insert_flag[species_max];
extern int   omit_flag[species_max];
 
extern char  lmt[size_char][element_max] ;
extern char  mt[size_char][mt_size] ;
extern char  nam[size_char][sub_size] ;
 
void arrays_clear(char *blank_pt)
{
 
  int i;
  int j;
 
//start clear_blank
  for(i=0;i<blank_size;i++)
  {
    *(blank_pt+i) = ' ';
  } // end clear_blank
//start clear_omit_flag
  for(i=0;i<species_max;i++)
  {
    omit_flag[i] = 0;
  } // end clear_omit_flag
//start clear_insert_flag
  for(i=0;i<species_max;i++)
  {
    insert_flag[i] = 0;
  } // end clear_insert_flag
//start initialize_lmt_first
  for(i=0;i<size_char;i++)
  {
//  start initialize_lmt_second
    for(j=0;j<lmt_size;j++)
    {
      lmt[i][j] = ' ';
    } // end initialize_lmt_second
  } // end initialize_lmt_first
//start set_mt1
  for(i=0;i<mt_size;i++)
  {
//  start set_mt2
    for(j=0;j<size_char;j++)
    {
      mt[j][i] = ' ';
    } // end set_mt2
  } // end set_mt1
//start set_nam1
  for(i=0;i<sub_size;i++)
  {
//  start set_nam2
    for(j=0;j<size_char;j++)
    {
      nam[j][i] = ' ';
    } // end set_nam2
  } // end set_nam1
//start set_b
  for(i=0;i<b_size;i++)
  {
    b[i] = 0.0;
  } // end set_b
 
} // end function arrays_clear
//###
//*****************************************************************************
//                                                                            *
//     Function Name: check_input                                             *
//                                                                            *
//     File Name: check_input.cpp                                             *
//                                                                            *
//     Purpose:  Reads the values following the "NAME" code record for the    *
//               temp, gas input, rsize, kase, and tri values.  Performs      *
//               checks on their limits and validity.                         *
//                                                                            *
//     Author:    Robert L. Reese                                             *
//                                                                            *
//     Date: January 08, 2004                                                 *
//                                                                            *
//     Language: Borland C++ Compiler, Version 4.5                            *
//                                                                            *
//     Hardware: IBM Compatible PC                                            *
//                                                                            *
//     Operating System: Microsoft Windows 98                                 *
//                                                                            *
//     Update History:                                                        *
//                                                                            *
//     Name        Date      Revision          Changes                        *
//     ----        ----      ---------         -------                        *
//                                                                            *
//    R.L. Reese   01/07/04      0             Initial Release                *
//    R.L. Reese   04/12/06      A             Added check for new_thermo     *
//                                             input value.                   *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//  Usage:                                                                    *
//                                                                            *
//     check_input(input_unit,                                                *
//                 output_unit,                                               *
//                 break_value_pt,                                            *
//                 read_error_pt)                                             *
//      where:                                                                *
//                                                                            *
//     input_unit     - FILE pointer to logical unit for input record         *
//     output_unit    - FILE pointer to logical unit for output listing file  *
//     break_vaue_pt  - Integer logical pointer to indicate if calling        *
//                      function needs to exit loop on return                 *
//     read_error_pt  - Integer pointer to indicate if error occurred         *
//                      = FALSE, no error                                     *
//                      = TRUE, error                                         *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//     Definitions:                                                           *
//                                                                            *
//     Local Variables:                                                       *
//     ----------------                                                       *
//                                                                            *
//     adata          - Character buffer containing data returned from        *
//                      init_read                                             *
//     blank          - Character buffer containing blanks                    *
//     eof            - Integer value of status returned from init_read       *
//     empty_file     - Integer value of status returned from init_read       *
//     first_time     - Logical flag indicating if first time through         *
//                      outer loop                                            *
//     i              - Integer for loop index                                *
//     j              - Integer for loop index                                *
//     nbytes         - Integer value of number of bytes from init_read       *
//     nmove          - Integer value of number of digits to move from        *
//                      input record for reactant values                      *
//     read_status    - Integer status of read operation                      *
//     real_buf       - Character array used for conversions                  *
//                                                                            *
//     Pointers                                                               *
//     -----------------                                                      *
//                                                                            *
//     adata_pt      - Character pointer to data from init_read               *
//     break_value   - Integer pointer to value indicating if error           *
//                     occurred in called function                            *
//     empty_file_pt - Integer pointer to empty file value from               *
//                     init_read                                              *
//     end_ptr       - Character pointer to error in strtod                   *
//     eof_pt        - Integer pointer to eof value from init_read            *
//     nbytes_pt     - Integer pointer to number of bytes read from           *
//                     init_read                                              *
//     read_status_pt- Integer pointer to current read status                 *
//     real_buf_pt   - Character pointer to buffer used for conversions       *
//                                                                            *
//     Global Variables:                                                      *
//     -----------------                                                      *
//                                                                            *
//     local - used by check_input and check_limits                           *
//     dum1         - Character used to output value of temp input            *
//     dum2         - Character used to output value of gas input             *
//     indx.h                                                                 *
//     kase         - Integer identification number for problem being         *
//                    considered                                              *
//     misc.h                                                                 *
//     tri          - Real value of increment of mole fraction for all        *
//                    reactants of ternary system                             *
//     points.h                                                               *
//     gas_input    - Logical variable used to determine if gas is used       *
//     rsize        - Real value used to determine size of mole fraction      *
//                    values for gas specie to be output                      *
//     tem          - Logical variable used to denote that for each           *
//                    assigned T there is an assigned P                       *
//                                                                            *
//     Constants:                                                             *
//     ---------                                                              *
//                                                                            *
//     local                                                                  *
//     FALSE           - Defines value of logical false = 0                   *
//     TRUE            - Defines value of logical true = 1                    *
//     arrays.h                                                               *
//     adata_len       - Integer variable used as length of adata array       *
//     blank_length    - Integer variable used as length of blank array       *
//     real_buf_len    - Integer variable used as size of real_buf            *
//     constant.h                                                             *
//     flag_position   - Integer variable used as position of tem and gas     *
//                       input flags default                                  *
//     iblank          - Character*1 containing a blank                       *
//     kase_default    - Integer variable used as default value for kase      *
//     kase_inc        - Integer value of increment to use for kase position  *
//     kase_loop       - Integer value of loop index to get kase value        *
//     kase_moves      - Integer value of maximum number of moves for kase    *
//     kase_position   - Integer variable used as position of kase default    *
//     kase_test       - Integer value to test for default of kase value      *
//     newt_position   - Integer variable used as position of new_thermo      *
//                       input flag default                                   *
//     not_flag        - Character containing flag off character (default)    *
//     num_radix       - Integer radix value used in converting integers      *
//     rsize_inc       - Integer value of increment to use for rsize position *
//     rsize_loop      - Integer value of loop index to get rsize value       *
//     rsize_moves     - Integer value of maximum number of moves for rsize   *
//     rsize_position  - Integer value used as position of rsize default      *
//     rsize_test      - Integer value to test for default of rsize value     *
//     tri_inc         - Integer value of increment to use for rsize position *
//     tri_loop        - Integer value of loop index to get rsize value       *
//     tri_moves       - Integer value of maximum number of moves for rsize   *
//     tri_position    - Integer value used as position of rsize default      *
//     tri_test        - Integer value to test for default of rsize value     *
//     string_end      - Character containing end of string control character *
//                                                                            *
//     Include Files:                                                         *
//     -------------                                                          *
//                                                                            *
//     arrays.h          - Contains sizes for include files                   *
//     constant.h        - Contains various constants and sizes               *
//     indx.h            - Contains index variables                           *
//     iostream.h        - Contains I/O routintes                             *
//     misc.h            - Contains miscellaneous variables                   *
//     points.h          - Contains temperature and pressure variables        *
//     stdio.h           - Contains C++ I/O routines                          *
//     stdlib.h          - Contains C++ standard library routines             *
//     string.h          - Contains C++ string routines                       *
//                                                                            *
//                                                                            *
//     External Software:                                                     *
//     -----------------                                                      *
//                                                                            *
//     check_limits  - Routine to check limits of rsize, tem and gas_input    *
//     check_systems - Routine used to insure proper add, top and base values *
//                     combinations are used for proper system being used     *
//     init_read     - Routine used to read the input record containing the   *
//                     required input values                                  *
//     strncpy       - C++ routine to copy strings                            *
//     strtod        - C++ routine to convert from ascii to float             *
//     strtol        - C++ routine to convert from ascii to long              *
//                                                                            *
//     Files:                                                                 *
//     -----                                                                  *
//                                                                            *
//       Input Files:                                                         *
//                                                                            *
//       input_unit  - Logical device for input reading                       *
//                                                                            *
//       Intermediate Files:                                                  *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Output Files:                                                        *
//                                                                            *
//       output_unit - logical device for output listings                     *
//                                                                            *
//*****************************************************************************
//###
 
#include "arrays.h"
#include "indx.h"
#include "misc.h"
#include "points.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream.h>
 
#define FALSE 0
#define TRUE  1
 
char  dum1;
char  dum2;
char  dum3;
 
void check_limits(FILE *output_unit,
                   int *break_value_pt,
                   int *read_error_pt);
 
void check_systems(FILE *output_unit,
                   int *break_value_pt,
                   int *read_status_pt);
 
void init_read(char *idata,
               int *eof,
               FILE *opu,
               FILE *inp_unit,
               int *empty_file,
               int *nbytes_pt);
 
void check_input(FILE *input_unit,
                 FILE *output_unit,
                 int *break_value_pt,
                 int *read_error_pt)
{
 
#include "constant.h"
 
  int   empty_file;
  int   eof;
  int   i;
  int   j;
  int   nbytes;
  int   nmove;
  int   read_status;
 
  char  adata[adata_len];
  char  blank[blank_length];
  char  real_buf[real_buf_len];
 
//  pointers
 
  char  *adata_pt;
  char  *end_ptr = "abcde";
  int   *eof_pt;
  int   *empty_file_pt;
  int   *nbytes_pt;
  int   *read_status_pt;
  char  *real_buf_pt;
 
//start initialize blank
  for(i=0;i<blank_length;i++)
  {
    blank[i] = iblank;
  } // end initialize blank
 
  adata_pt       = &adata[0];
  empty_file_pt  = &empty_file;
  eof_pt         = &eof;
  nbytes_pt      = &nbytes;
  read_status_pt = &read_status;
  real_buf_pt    = &real_buf[0];
  *break_value_pt = FALSE;
 
//start do_while_loop
  for(;;)
  {
 
//     Input case no., rsize value, PLUS system increment, tem option and
//     gas input option
 
    *eof_pt = 0;
    init_read(adata_pt,eof_pt,output_unit,input_unit,
              empty_file_pt,nbytes_pt);
//  start name_error
    if(*eof_pt !=0)
    {
//    exit do_while
      *break_value_pt = TRUE;
      break ;
    } // end name_error
//  start temp_default
    if(*(nbytes_pt)<flag_position)
    {
      dum1 = not_flag;
    }
    else
    {
      dum1 = *(adata);
//    start temp_blank
      if(dum1 == iblank)
      {
        dum1 = not_flag;
      } // end temp_blank
    } // end temp_default
 
//  start gas_input_default
    if(*(nbytes_pt)<flag_position)
    {
      dum2 = not_flag;
    }
    else
    {
      dum2 = *(adata+1);
//    start gas_input_blank
      if(dum2 == iblank)
      {
        dum2 = not_flag;
      } // end gas_input_blank
    } // end gas_input_default
 
//  start kase_default_check
    if(*nbytes_pt < kase_position)
    {
      kase = kase_default;
    }
    else
    {
      strncpy(real_buf_pt,&blank[0],blank_length);
      *(real_buf_pt+blank_length) = string_end;
//    start compute_kase_moves
      if(*nbytes_pt > kase_test)
      {
        nmove = kase_moves;
      }
      else
      {
        nmove = *nbytes_pt - (kase_inc+1);
      } // end compute_kase_moves
      strncpy(real_buf_pt,adata_pt+kase_inc,nmove);
//    start kase_find_blanks
      for(j=kase_loop;j>=0;j=j-1)
      {
//       start kase_found_nonblank
         if(*(real_buf_pt+j) != iblank)
         {
//         exit kase_find_blanks
           break;
         } // end kase_found_nonblank
      } // end kase_find_blanks
      strncpy(real_buf_pt,adata_pt+kase_inc,nmove);
      kase = strtol(real_buf_pt,&end_ptr,num_radix);
//    start kase_error
      if(end_ptr != (real_buf_pt+(j+1)))
      {
        fprintf(output_unit," Error in KASE Number\n");
        cout << " Error in KASE Number"<<endl;
        *read_error_pt = TRUE;
//      exit do_while_loop
       *break_value_pt = TRUE;
        break;
      } // end kase_error
    }
 
//  start rsize_default_check
    if(*nbytes_pt < rsize_position)
    {
      rsize = 0.0;
    }
    else
    {
      strncpy(real_buf_pt,&blank[0],blank_length);
      *(real_buf_pt+blank_length) = string_end;
//    start compute_rsize_moves
      if(*nbytes_pt > rsize_test)
      {
        nmove = rsize_moves;
      }
      else
      {
        nmove = *nbytes_pt - (rsize_inc+1);
      } // end compute_rsize_moves
      strncpy(real_buf_pt,adata_pt+rsize_inc,nmove);
//    start rsize_find_blanks
      for(j=rsize_loop;j>=0;j=j-1)
      {
//       start rsize_found_nonblank
         if(*(real_buf_pt+j) != iblank)
         {
//         exit rsize_find_blanks
           break;
         } // end rsize_found_nonblank
      } // end rsize_find_blanks
      strncpy(real_buf_pt,adata_pt+rsize_inc,nmove);
      rsize = strtod(real_buf_pt,&end_ptr);
//    start rsize_error
      if(end_ptr != (real_buf_pt+(j+1)))
      {
        fprintf(output_unit," Error in RSIZE Value\n");
        cout << " Error in RSIZE Value"<<endl;
        *read_error_pt = TRUE;
//      exit do_while_loop
       *break_value_pt = TRUE;
        break;
      } // end rsize_error
    } // end rsize_default_check
 
//  start tri_default_check
    if(*nbytes_pt < tri_position)
    {
      tri = 0.0;
    }
    else
    {
      strncpy(real_buf_pt,&blank[0],blank_length);
      *(real_buf_pt+blank_length) = string_end;
//    start compute_tri_moves
      if(*nbytes_pt > tri_test)
      {
        nmove = tri_moves;
      }
      else
      {
        nmove = *nbytes_pt - (tri_inc+1);
      } // end compute_tri_moves
      strncpy(real_buf_pt,adata_pt+tri_inc,nmove);
//    start tri_find_blanks
      for(j=tri_loop;j>=0;j=j-1)
      {
//       start tri_found_nonblank
         if(*(real_buf_pt+j) != iblank)
         {
//         exit tri_find_blanks
           break;
         } // end tri_found_nonblank
      } // end tri_find_blanks
      tri = strtod(real_buf_pt,&end_ptr);
//    start tri_error
      if(end_ptr != (real_buf_pt+(j+1)))
      {
        cout << " Error in TRI Value"<<endl;
        fprintf(output_unit," Error in TRI Value\n");
        *read_error_pt = TRUE;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      } // end tri_error
    } // end tri_default_check
//      start tri_range
    if(tri < 0.0)
    {
      fprintf(output_unit,
      " Error - TRI value must be greater than or equal to zero\n");
      cout << " Error - TRI value must be greater than or equal to zero"
      <<endl;
      *read_status_pt = 1;
//    exit do_while_loop
      *break_value_pt = TRUE;
      break;
    } // end tri_range
 
//  start new_thermo_default
    if(*(nbytes_pt)<newt_position)
    {
      dum3 = not_flag;
    }
    else
    {
      dum3 = *(adata+(newt_position-1));
//    start newt_blank
      if(dum3 == iblank)
      {
        dum3 = not_flag;
      } // end newt_blank
    } // end new_thermo_default
 
//  check the alter, systm and plus values for base, top and add
 
    *break_value_pt = FALSE;
    *read_status_pt = 0;
    check_systems(output_unit,
                  break_value_pt,
                  read_status_pt);
 
//  start check_systems_error
    if(*break_value_pt || *read_status_pt != 0)
    {
//    exit do_while_loop
      break;
    }
 
// check limits of rsize, tem and gas_input
 
    check_limits(output_unit,
                 break_value_pt,
                 read_error_pt);
 
//  start limit_error
    if(*break_value_pt)
    {
//    exit do_while_loop
      break;
    } // end limit_error
 
    fprintf(output_unit,"\n CASE NUMBER %6d     RSIZE =%11.3f",
                         kase,rsize);
    fprintf(output_unit," TRI =%9.1f TEMP = %c",tri,dum1);
    fprintf(output_unit,"     GAS = %c\n",dum2);
    fprintf(output_unit," NEW THERMO = %c\n\n",dum3);
//  exit do_while_loop
    break;
  } // end do_while
 
//start set_read_error
  if(*read_status_pt != 0)
  {
    *read_error_pt = TRUE;
  } // end set_read_error
 
} // end function check_input
//###
//*****************************************************************************
//                                                                            *
//     Function Name: check_insert                                            *
//                                                                            *
//     File Name: check_insert.cpp                                            *
//                                                                            *
//     Purpose:  Process the species names in the insert records and stores   *
//               them.                                                        *
//                                                                            *
//     Author:    Robert L. Reese                                             *
//                                                                            *
//     Date: January 08, 2004                                                 *
//                                                                            *
//     Language: Borland C++ Compiler, Version 4.5                            *
//                                                                            *
//     Hardware: IBM Compatible PC                                            *
//                                                                            *
//     Operating System: Microsoft Windows 98                                 *
//                                                                            *
//     Update History:                                                        *
//                                                                            *
//     Name        Date      Revision          Changes                        *
//     ----        ----      ---------         -------                        *
//                                                                            *
//    R.L. Reese   01/07/04      0             Initial Release                *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//  Usage:                                                                    *
//                                                                            *
//     check_insert(adata_pt,                                                 *
//                  nbytes_pt)                                                *
//      where:                                                                *
//                                                                            *
//     adata_pt       - Integer pointer to current record being processed     *
//     nbytes_pt      - Integer pointer to number of bytes in current record  *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//     Definitions:                                                           *
//                                                                            *
//     Local Variables:                                                       *
//     ----------------                                                       *
//                                                                            *
//     i              - Integer for loop index                                *
//     j              - Integer for loop index                                *
//     kount          - Integer value pointing to current element in record   *
//                                                                            *
//     Pointers                                                               *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Global Variables:                                                      *
//     -----------------                                                      *
//                                                                            *
//     indx.h                                                                 *
//     nsert        - Integer value of number of species listed on insert     *
//                    records                                                 *
//     speces.h                                                               *
//     ensert       - Character*4 variable containing ith specie of n         *
//                    species which are specified to be considered for        *
//                    inputting                                               *
//                                                                            *
//     Constants:                                                             *
//     ---------                                                              *
//                                                                            *
//     constant.h                                                             *
//     first_name      - Integer value of number of characters in name        *
//     first_start     - Integer value of start of first name                 *
//     iblank          - Character*1 containing a blank                       *
//     max_names       - Integer value of maximum number of names in one      *
//                       record                                               *
//     second_check    - Integer value for check if second name present       *
//     second_name     - Integer value for start of second name               *
//                                                                            *
//     Include Files:                                                         *
//     -------------                                                          *
//                                                                            *
//     arrays.h          - Contains sizes for include files                   *
//     constant.h        - Contains various constants and sizes               *
//     indx.h            - Contains index variables                           *
//     speces.h          - Contains species variables                         *
//                                                                            *
//                                                                            *
//     External Software:                                                     *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Files:                                                                 *
//     -----                                                                  *
//                                                                            *
//       Input Files:                                                         *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Intermediate Files:                                                  *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Output Files:                                                        *
//                                                                            *
//       None                                                                 *
//                                                                            *
//*****************************************************************************
//###
 
#include "arrays.h"
#include "indx.h"
#include "speces.h"
 
void check_insert(char *adata_pt,
                  int *nbytes_pt)
{
 
#include "constant.h"
 
  int i;
  int j;
  int kount;
 
  kount = first_name;
//start check_insert_name
  for(i = 0; i< max_names;i++)
  {
//  start check_insert_test
    if(*(adata_pt+kount) != iblank)
    {
//    start check_insert_letters
      for(j = 0;j < first_start ;j++)
      {
        ensert[j][nomit] = iblank;
//      start check_insert_name
        if(kount < (*(nbytes_pt)-1))
        {
          ensert[j][nsert] = *(adata_pt+kount) ;
          kount++;
        }
        else
        {
//        exit check_insert_letters
          break;
        } // end check_insert_name
      } // end check_insert_letters
      kount = second_name;
    } // end check_insert_test
    nsert = nsert+1 ;
//  start second_check_insert_name
    if(*nbytes_pt < second_check)
    {
//    exit check_insert_name
      break;
    } // end second_check_insert_name
  } // end check_insert_name
 
} // end function check_insert
//###
//*****************************************************************************
//                                                                            *
//     Function Name: check_limits                                            *
//                                                                            *
//     File Name: check_limits.cpp                                            *
//                                                                            *
//     Purpose:  Performs checks on rsize, tem and gas_input limits and       *
//               validity.                                                    *
//                                                                            *
//     Author:    Robert L. Reese                                             *
//                                                                            *
//     Date: January 08, 2004                                                 *
//                                                                            *
//     Language: Borland C++ Compiler, Version 4.5                            *
//                                                                            *
//     Hardware: IBM Compatible PC                                            *
//                                                                            *
//     Operating System: Microsoft Windows 98                                 *
//                                                                            *
//     Update History:                                                        *
//                                                                            *
//     Name        Date      Revision          Changes                        *
//     ----        ----      ---------         -------                        *
//                                                                            *
//    R.L. Reese   01/07/04      0             Initial Release                *
//    R.L. Reese   04/12/06      A             Added new parameter for        *
//                                             checking for type of thermo    *
//                                             data will be used              *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//  Usage:                                                                    *
//                                                                            *
//     check_limits(output_unit,                                              *
//                  break_value_pt,                                           *
//                  read_error_pt)                                            *
//      where:                                                                *
//                                                                            *
//     input_unit     - FILE pointer to logical unit for input record         *
//     output_unit    - FILE pointer to logical unit for output listing file  *
//     break_vaue_pt  - Integer logical pointer to indicate if calling        *
//                      function needs to exit loop on return                 *
//     read_error_pt  - Integer pointer to indicate if error occurred         *
//                      = FALSE, no error                                     *
//                      = TRUE, error                                         *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//     Definitions:                                                           *
//                                                                            *
//     Local Variables:                                                       *
//     ----------------                                                       *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Pointers                                                               *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Global Variables:                                                      *
//     -----------------                                                      *
//                                                                            *
//     local - used by check_input and check_limits                           *
//     dum1         - Character used to output value of temp input            *
//     dum2         - Character used to output value of gas input             *
//     dum3         - Character used to output value of new_thermo input      *
//     points.h                                                               *
//     gas_input    - Logical variable used to determine if gas is used       *
//     rsize        - Real value used to determine size of mole fraction      *
//                    values for gas specie to be output                      *
//     tem          - Logical variable used to denote that for each           *
//                    assigned T there is an assigned P                       *
//                                                                            *
//     Constants:                                                             *
//     ---------                                                              *
//                                                                            *
//     local                                                                  *
//     FALSE           - Defines value of logical false = 0                   *
//     TRUE            - Defines value of logical true = 1                    *
//     constant.h                                                             *
//     not_flag        - Character containing flag of character (default)     *
//     yes_flag        - Character containing flag "Y" character              *
//                                                                            *
//     Include Files:                                                         *
//     -------------                                                          *
//                                                                            *
//     arrays.h          - Contains sizes for include files                   *
//     constant.h        - Contains constants and sizes                       *
//     iostream.h        - Contains I/O routintes                             *
//     points.h          - Contains temperature and pressure variables        *
//     stdio.h           - Contains FILE declaration                          *
//                                                                            *
//                                                                            *
//     External Software:                                                     *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Files:                                                                 *
//     -----                                                                  *
//                                                                            *
//       Input Files:                                                         *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Intermediate Files:                                                  *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Output Files:                                                        *
//                                                                            *
//       output_unit - logical device for output listings                     *
//                                                                            *
//*****************************************************************************
//###
 
#include "arrays.h"
#include <iostream.h>
#include "points.h"
#include <stdio.h>
 
#define FALSE 0
#define TRUE  1
 
extern  char  dum1;
extern  char  dum2;
extern  char  dum3;
 
void check_limits(FILE *output_unit,
                  int *break_value_pt,
                  int *read_error_pt)
{
 
#include "constant.h"
 
  *break_value_pt = FALSE;
 
//start do_while_loop
  for(;;)
  {
 
//  start rsize_range
    if(rsize < 0.0)
    {
      fprintf(output_unit,
      " Error - RSIZE value must be greater than or equal to zero\n");
      cout << " Error - RSIZE value must be greater than or equal to zero" << endl;
      *read_error_pt = TRUE;
//    exit do_while_loop
      *break_value_pt = TRUE;
      break;
    } // end rsize_range
 
//  start tem_check
    if(dum1 == yes_flag)
    {
      tem = TRUE;
    }
    else if(dum1 != not_flag)
    {
      fprintf(output_unit," Error in TEM Value\n");
      cout << " Error in TEM Value" << endl;
      *read_error_pt = TRUE;
//    exit do_while_loop
      *break_value_pt = TRUE;
      break;
    } // end tem_check
//  start gas_input_check
    if(dum2 == yes_flag)
    {
      gas_input = TRUE;
    }
    else if(dum2 != not_flag)
    {
      fprintf(output_unit," Error in GAS INPUT Value\n");
      cout << " Error in GAS INPUT Value" << endl;
      *read_error_pt = TRUE;
//    exit do_while_loop
      *break_value_pt = TRUE;
      break;
    } // end gas_input_check
    gas_input = TRUE ;
    dum2 = yes_flag;
 
//  start new_thermo_check
    if(dum3 == yes_flag)
    {
      new_thermo = TRUE;
    }
    else if(dum3 != not_flag)
    {
      fprintf(output_unit," Error in NEW_THERMO Value\n");
      cout << " Error in NEW_THERMO Value" << endl;
      *read_error_pt = TRUE;
//    exit do_while_loop
      *break_value_pt = TRUE;
      break;
    } // end new_thermo_check
 
//  exit do_while_loop
    break;
 
  } // end do_while_loop
 
} // end function check_limits
//###
//*****************************************************************************
//                                                                            *
//     Function Name: check_omit                                              *
//                                                                            *
//     File Name: check_omit.cpp                                              *
//                                                                            *
//     Purpose:  Process the species names in the omit records and stores     *
//               them.                                                        *
//                                                                            *
//     Author:    Robert L. Reese                                             *
//                                                                            *
//     Date: January 08, 2004                                                 *
//                                                                            *
//     Language: Borland C++ Compiler, Version 4.5                            *
//                                                                            *
//     Hardware: IBM Compatible PC                                            *
//                                                                            *
//     Operating System: Microsoft Windows 98                                 *
//                                                                            *
//     Update History:                                                        *
//                                                                            *
//     Name        Date      Revision          Changes                        *
//     ----        ----      ---------         -------                        *
//                                                                            *
//    R.L. Reese   01/07/04      0             Initial Release                *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//  Usage:                                                                    *
//                                                                            *
//     check_omit(adata_pt,                                                   *
//                nbytes_pt)                                                  *
//      where:                                                                *
//                                                                            *
//     adata_pt       - Integer pointer to current record being processed     *
//     nbytes_pt      - Integer pointer to number of bytes in current record  *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//     Definitions:                                                           *
//                                                                            *
//     Local Variables:                                                       *
//     ----------------                                                       *
//                                                                            *
//     i              - Integer for loop index                                *
//     j              - Integer for loop index                                *
//     kount          - Integer value pointing to current element in record   *
//                                                                            *
//     Pointers                                                               *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Global Variables:                                                      *
//     -----------------                                                      *
//                                                                            *
//     indx.h                                                                 *
//     nomit        - Integer value of number of species listed on omit       *
//                    records                                                 *
//     speces.h                                                               *
//     omit         - Character*4 variable containing ith specie of n         *
//                    species which are specified to be considered for        *
//                    omitting                                                *
//                                                                            *
//     Constants:                                                             *
//     ---------                                                              *
//                                                                            *
//     constant.h                                                             *
//     first_name      - Integer value of number of characters in name        *
//     first_start     - Integer value of start of first name                 *
//     iblank          - Character*1 containing a blank                       *
//     max_names       - Integer value of maximum number of names in one      *
//                       record                                               *
//     second_check    - Integer value for check if second name present       *
//     second_name     - Integer value for start of second name               *
//                                                                            *
//     Include Files:                                                         *
//     -------------                                                          *
//                                                                            *
//     arrays.h          - Contains sizes for include files                   *
//     constant.h        - Contains various constants and sizes               *
//     indx.h            - Contains index variables                           *
//     speces.h          - Contains species variables                         *
//                                                                            *
//                                                                            *
//     External Software:                                                     *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Files:                                                                 *
//     -----                                                                  *
//                                                                            *
//       Input Files:                                                         *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Intermediate Files:                                                  *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Output Files:                                                        *
//                                                                            *
//       None                                                                 *
//                                                                            *
//*****************************************************************************
//###
 
#include "arrays.h"
#include "constant.h"
#include "indx.h"
#include "speces.h"
 
void check_omit(char *adata_pt,
                int *nbytes_pt)
{
  int i;
  int j;
  int kount;
 
  kount = first_name;
 
//start check_omit_name
  for(i = 0; i< max_names;i++)
  {
//  start check_omit_test
    if(*(adata_pt+kount) != iblank)
    {
//    start check_omit_letters
      for(j = 0;j < first_start ;j++)
      {
        omit[j][nomit] = iblank;
//      start get_check_omit_name
        if(kount < ((*nbytes_pt)-1))
        {
          omit[j][nomit] = *(adata_pt+kount) ;
          kount++;
        }
        else
        {
//        exit check_omit_letters
          break;
        } // end get_check_omit_name
      } // end check_omit_letters
      kount = second_name;
    } // end check_omit_test
    nomit = nomit+1 ;
//  start second_omit
    if(*nbytes_pt < second_check)
    {
//    exit check_omit_name
      break;
    } // end second_omit
  } //  end check_omit_name
} // end function check_omit
//###
//*****************************************************************************
//                                                                            *
//     Function Name: check_systems                                           *
//                                                                            *
//     File Name: check_systems.cpp                                           *
//                                                                            *
//     Purpose:  Verify the correct base, top, add and tri values for the     *
//               Alter, Systm and Plus problems                               *
//                                                                            *
//     Author:    Robert L. Reese                                             *
//                                                                            *
//     Date: January 08, 2004                                                 *
//                                                                            *
//     Language: Borland C++ Compiler, Version 4.5                            *
//                                                                            *
//     Hardware: IBM Compatible PC                                            *
//                                                                            *
//     Operating System: Microsoft Windows 98                                 *
//                                                                            *
//     Update History:                                                        *
//                                                                            *
//     Name        Date      Revision          Changes                        *
//     ----        ----      ---------         -------                        *
//                                                                            *
//    R.L. Reese   01/07/04      0             Initial Release                *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//  Usage:                                                                    *
//                                                                            *
//    check_systems(output_unit,                                              *
//                  break_value_pt,                                           *
//                  read_status_pt)                                           *
//      where:                                                                *
//                                                                            *
//     output_unit    - FILE pointer to logical output listing unit           *
//     break_value    - Integer logical pointer indicating if loop needs to   *
//                      be exited upon return                                 *
//     read_status_pt - Integer pointer to read error flag                    *
//                      = 0, no error                                         *
//                      = 1, error                                            *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//     Definitions:                                                           *
//                                                                            *
//     Local Variables:                                                       *
//     ----------------                                                       *
//                                                                            *
//     i              - Integer for loop index                                *
//                                                                            *
//     Pointers                                                               *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Global Variables:                                                      *
//     -----------------                                                      *
//                                                                            *
//     indx.h                                                                 *
//     nreac        - Integer value of number of reactant records read        *
//     plus         - Logical variable used to indicate if reactants          *
//                    are to be added to the system or if a ternary           *
//                    system is being considered                              *
//     systm        - Logical variable used to denote that a ternary          *
//                    system is being considered                              *
//     misc.h                                                                 *
//     add          - Real array containing increment of ith reactant mole    *
//                    fraction                                                *
//     base         - Real array containing first value of mole fraction of   *
//                    ith reactant                                            *
//     top          - Real array containing final value of mole fraction of   *
//                    ith reactant                                            *
//     tri          - Real value of increment of mole fraction for all        *
//                    reactants of ternary system                             *
//                                                                            *
//     Constants:                                                             *
//     ---------                                                              *
//                                                                            *
//     local                                                                  *
//     FALSE           - Defined value for false logical test = 0             *
//     TRUE            - Defined value for true logical test = 1              *
//     constant.h                                                             *
//     nreac_test      - Integer value of number of reactants for ternary     *
//                       system                                               *
//     third_add_indx  - Integer value of index to third add value in ternary *
//                       system                                               *
//                                                                            *
//     Include Files:                                                         *
//     -------------                                                          *
//                                                                            *
//     arrays.h          - Contains sizes for include files                   *
//     constant.h        - Contains constants and sizes                       *
//     indx.h            - Contains index variables                           *
//     iostream.h        - Contains I/O routines                              *
//     misc.h            - Contains miscellaneous variables                   *
//     stdio.h           - Contains FILE declaration                          *
//                                                                            *
//                                                                            *
//     External Software:                                                     *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Files:                                                                 *
//     -----                                                                  *
//                                                                            *
//       Input Files:                                                         *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Intermediate Files:                                                  *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Output Files:                                                        *
//                                                                            *
//       output_unit - logical device for output listings                     *
//                                                                            *
//*****************************************************************************
//###
 
#include "arrays.h"
#include "indx.h"
#include <iostream.h>
#include "misc.h"
#include <stdio.h>
 
#define FALSE 0
#define TRUE  1
 
void check_systems(FILE *output_unit,
                   int *break_value_pt,
                   int *read_status_pt)
{
 
#include "constant.h"
 
  int i;
 
  *break_value_pt = FALSE;
  *read_status_pt = 0;
 
//start do_while_loop
  for(;;)
  {
//  start systm_tri_error
    if(systm)
    {
//    start tri_check
      if(tri <= 0.0)
      {
        cout <<
        " Error - SYSTM problem must have positive non-zero tri value"
        << endl;
        fprintf(output_unit,
        " Error - SYSTM problem must have positive non-zero tri value\n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      }
      else if(add[0] != -(tri))
      {
        cout <<
        " Error - SYSTM problem first add must be equal to negative tri value"
        << endl;
        fprintf(output_unit,
        " Error - SYSTM problem first add must be equal to negative tri value\n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      }
      else if(add[1] != tri)
      {
        cout <<
        " Error - SYSTM problem second add must equal positive tri value"
        << endl;
        fprintf(output_unit,
        " Error - SYSTM problem second add must equal positivetri value\n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      } // end tri_check
    } // end systm_tri_error
 
//   Verify base, top and add values for Plus Problems with zero tri value
 
//  start plus_no_tri
    if(plus && tri == 0.0)
    {
//    start loop_plus
      for(i=0;i<nreac;i++)
      {
//      start no_tri_plus
        if(base[i] != top[i])
        {
          cout <<
          " Error - PLUS problem base must equal top" <<endl;
          fprintf(output_unit,
          " Error - PLUS problem base must equal top\n");
          *read_status_pt = 1;
//        exit do_while_loop
          *break_value_pt = TRUE;
          break;
        }
        else if(base[i] != 0.0 && add[i] != 0.0)
        {
          cout <<
          " Error - PLUS problem add must equal zero if base not zero"
          << endl;
          fprintf(output_unit,
          " Error - PLUS problem add must equal zero if base not zero\n");
          *read_status_pt = 1;
//        exit do_while_loop
          *break_value_pt = TRUE;
          break;
        }
        else if(base[i] == 0.0 && add[i] < 0.0)
        {
          cout <<
          " Error - PLUS problem add must be positive non-zero if base zero"
          << endl;
          fprintf(output_unit,
          " Error - PLUS problem add must be positive non-zero if base zero\n");
          *read_status_pt = 1;
//        exit do_while_loop
          *break_value_pt = TRUE;
          break;
        } // end no_tri_plus
      } // end loop_plus
//    start exit_loop
      if(*read_status_pt == 1)
      {
//        exit do_while_loop
        *break_value_pt = TRUE;
        break;
      } // end exit_loop
//    start base_zero
      if(base[0] == 0.0)
      {
        cout <<
        " Error - PLUS problem first base and top must be positive non-zero"
          << endl;
        fprintf(output_unit,
        " Error - PLUS problem first base and top must be positive non-zero\n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      } // end base_zero
    } // end plus_no_tri
 
//   Verify base, top and add values for Plus Problems with non-zero tri value
 
//  start plus_tri
    if(plus && tri != 0.0)
    {
//    start test_plus_tri
      if(nreac != nreac_test)
      {
        cout <<
        " Error - PLUS problem (non-zero tri) only 3 reactants allowed"
          << endl;
        fprintf(output_unit,
        " Error - PLUS problem (non-zero tri) only 3 reactants allowed\n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      }
      else if(base[0] == 0.0)
      {
        cout <<
        " Error - PLUS (non-zero tri) problem first base must be greater than zero "
          << endl;
        fprintf(output_unit,
        " Error - PLUS (non-zero tri) problem first base must be greater than zero \n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      }
      else if(base[0] <= top[0])
      {
        cout <<
        " Error - PLUS (non-zero tri) problem first base must be greater than top "
          << endl;
        fprintf(output_unit,
        " Error - PLUS (non-zero tri) problem first base must be greater than top \n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      }
      else if(add[0] != 0.0)
      {
        cout <<
        " Error - PLUS (non-zero tri) problem first add must equal zero "
          << endl;
        fprintf(output_unit,
        " Error - PLUS (non-zero tri) problem first add must equal zero \n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      }
      else if(base[1] == 0.0)
      {
        cout <<
        " Error - PLUS (non-zero tri) problem second base must be greater than zero "
          << endl;
        fprintf(output_unit,
        " Error - PLUS (non-zero tri) problem second base must be greater than zero \n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      }
      else if(base[1] >= top[1])
      {
        cout <<
        " Error - PLUS (non-zero tri) problem second base must be less than top "
          << endl;
        fprintf(output_unit,
        " Error - PLUS (non-zero tri) problem second base must be less than top \n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      }
      else if(add[1] != 0.0)
      {
        cout <<
        " Error - PLUS (non-zero tri) problem second add must equal zero "
          << endl;
        fprintf(output_unit,
        " Error - PLUS (non-zero tri) problem second add must equal zero \n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      }
      else if(add[third_add_indx] <= 0.0)
      {
        cout <<
        " Error - PLUS (non-zero tri) problem third add must be greater than zero "
          << endl;
        fprintf(output_unit,
        " Error - PLUS (non-zero tri) problem third add must be greater than zero \n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      }
      else if(add[third_add_indx] != tri)
      {
        cout <<
        " Error - PLUS (non-zero tri) problem third add must equal tri value "
          << endl;
        fprintf(output_unit,
        " Error - PLUS (non-zero tri) problem third add must equal tri value \n");
        *read_status_pt = 1;
//      exit do_while_loop
        *break_value_pt = TRUE;
        break;
      } // end test_plus_tri
    } // end plus_tri
//      exit do_while_loop
      break;
  } // end do_while_loop
} // end function check_systems
//###
//*****************************************************************************
//                                                                            *
//     Function Name: clear_arrays                                            *
//                                                                            *
//     File Name: clear_arrays.cpp                                            *
//                                                                            *
//     Purpose:  This function is called from react and clears specified      *
//               arrays before processing the reac records.                   *
//                                                                            *
//     Author:    Robert L. Reese                                             *
//                                                                            *
//     Date: January 28, 2004                                                 *
//                                                                            *
//     Language: Borland C++ Compiler, Version 4.5                            *
//                                                                            *
//     Hardware: IBM Compatible PC                                            *
//                                                                            *
//     Operating System: Microsoft Windows 98                                 *
//                                                                            *
//     Update History:                                                        *
//                                                                            *
//     Name        Date      Revision          Changes                        *
//     ----        ----      ---------         -------                        *
//                                                                            *
//    R.L. Reese   01/28/04      0             Initial Release                *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//  Usage:                                                                    *
//                                                                            *
//     clear_arrays(adata) where:                                             *
//                                                                            *
//     adata  - real pointer to real array used in react                      *
//                                                                            *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//     Definitions:                                                           *
//                                                                            *
//     Local Variables:                                                       *
//     ----------------                                                       *
//                                                                            *
//     i            - Integer variable used as do loop index                  *
//     j            - Integer variable used as do loop index                  *
//     n            - Integer variable used as do loop index                  *
//                                                                            *
//     Pointers                                                               *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Global Variables:                                                      *
//     -----------------                                                      *
//                                                                            *
//     indx.h                                                                 *
//     alter        - Logical variable indicating reactant mole factions with *
//                    unequal top and base values are to be altered           *
//     newmol       - Integer variable used to determine if reactant records  *
//                    have been read, and if type of mixture problem has been *
//                    determined.                                             *
//     misc.h                                                                 *
//     anum         - Real array containing stochiometric coefficients of     *
//                    elements on reactant records                            *
//     bo           - Real array containing assigned Kg-atoms of element i per*
//                    Kg of total reactant                                    *
//     llmt         - Character*4 containing alphameric symbols for the       *
//                    elements in the system being studied                    *
//     name         - Character*4 containing alphameric symbols for the       *
//                    elements as given in the reactant records               *
//                                                                            *
//     Constants:                                                             *
//     ---------                                                              *
//                                                                            *
//     arrays.h                                                               *
//     element_max     - Integer containing maximum number of elements allowed*
//     reacts_max      - Integer containing maximum number of reactants in a  *
//                       record                                               *
//     size_char       - Integer value used as len of char to replace default *
//                       length of 4 characters in one word for FORTRAN 4 and *
//                       FORTRAN 77 conversion                                *
//     constant.h                                                             *
//     iblank          - Character*1 containing a blank                       *
//                                                                            *
//     Include Files:                                                         *
//     -------------                                                          *
//                                                                            *
//     arrays.h          - Contains sizes for include files                   *
//     constants.h       - Contains various constants                         *
//     indx.h            - Contains index variables                           *
//     misc.h            - Contains miscellaneous variables                   *
//                                                                            *
//     External Software:                                                     *
//     -----------------                                                      *
//                                                                            *
//     None                                                                   *
//                                                                            *
//     Files:                                                                 *
//     -----                                                                  *
//                                                                            *
//       Input Files:                                                         *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Intermediate Files:                                                  *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Output Files:                                                        *
//                                                                            *
//       None                                                                 *
//                                                                            *
//*****************************************************************************
//###
 
#include "arrays.h"
#include "indx.h"
#include "misc.h"
 
void clear_arrays(float *adata)
{
 
#include "constant.h"
 
  int i;
  int j;
  int n;
 
//start first_time
  if(newmol == 0)
  {
//  start init_anum1
    for(i=0;i<element_max;i++)
    {
//    start init_anum2
      for(j=0;j<reacts_max;j++)
      {
       anum[i][j] = 0.0;
      } // end init_anum2
    } // end init_anum1
  } // end first_time
 
//start clear_arrays
  for (i=0;i<element_max;i++)
  {
    *(adata+i) = 0.0 ;
    bo[i] = 0.0 ;
  } // end clear_arrays
 
//start initial_llmt_first
  for(i=0;i<element_max;i++)
  {
//  start initial_llmt_second
    for(j=0;j<size_char;j++)
    {
      llmt[j][i] = iblank;
    } // end initial_llmt_second
  } // end initial_llmt_first
 
//start no_alter_clear
  if(!alter && ! systm && !plus)
  {
//  start initial_name_first
    for(n=0;n<reacts_max;n++)
    {
//    start initial_name_second
      for(i=0;i<element_max;i++)
      {
//      start initial_name_third
        for(j=0;j<size_char;j++)
        {
          name[j][i][n] = iblank;
        } // end initial_name_third
      } // end initial_name_second
    } // end initial_name_first
  } // end no_alter_clear
 
} // end function clear_arrays
//###
//*****************************************************************************
//                                                                            *
//     Function Name: coeff_read                                              *
//                                                                            *
//     File Name: coeff_read.cpp                                              *
//                                                                            *
//     Purpose:  Function called from read_coeff.  It only reads the 14       *
//               values per species and verifies the values.                  *
//                                                                            *
//     Author:    Robert L. Reese                                             *
//                                                                            *
//     Date: January 29, 2004                                                 *
//                                                                            *
//     Language: Borland C++ Compiler, Version 4.5                            *
//                                                                            *
//     Hardware: IBM Compatible PC                                            *
//                                                                            *
//     Operating System: Microsoft Windows 98                                 *
//                                                                            *
//     Update History:                                                        *
//                                                                            *
//     Name        Date      Revision          Changes                        *
//     ----        ----      ---------         -------                        *
//                                                                            *
//    R.L. Reese   01/29/04      0             Initial Release                *
//    R.L. Reese   03/06/06      A             Changed check for short        *
//                                             records. Include check for long*
//                                             records.  Records will be      *
//                                             truncated for long records     *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//  Usage:                                                                    *
//                                                                            *
//   coeff_read(read_unit,                                                    *
//              output_unit,                                                  *
//              empty_file_pt,                                                *
//              adata_pt,                                                     *
//              nbytes_pt,                                                    *
//              begin_loop_pt,                                                *
//              eof_pt,                                                       *
//              ibuf_pt,                                                      *
//              blank_pt)   where:                                            *
//                                                                            *
//     read_unit    - FILE pointer to thermodynamic data logical unit which   *
//                    may be the thermodynamic file or scratch file           *
//     output_unit  - FILE pointer to output listing logical unit             *
//     empty_file_pt- Integer pointer to empty file flag returned from        *
//                    init_read                                               *
//     adata_pt     - Character pointer to data returned from init_read       *
//     nbytes_pt    - Integer pointer to number of bytes read in init_read    *
//     begin_loop_pt- Integer logical pointer to flag indicating if calling   *
//                    function will return to beginning of loop               *
//     eof_pt       - Integer pointer containing status of last read          *
//     ibuf_pt      - Character pointer to array used to get values from the  *
//                    input records                                           *
//     blank_pt     - Character pointer to array containing blanks            *
//                                                                            *
//----------------------------------------------------------------------------*
//                                                                            *
//     Definitions:                                                           *
//                                                                            *
//     Local Variables:                                                       *
//     ----------------                                                       *
//                                                                            *
//     i              - Integer value used as do loop index                   *
//     j              - Integer value used as do loop index                   *
//     jj             - Integer value used as do loop index                   *
//     k              - Integer value used as do loop index                   *
//     kk             - Integer value used as do loop index                   *
//     kount          - Integer value used to compute maxns                   *
//     m              - Integer used as index for getting coefficients        *
//     num_coeff      - Integer value of number of coefficients in a record   *
//                                                                            *
//     Pointers                                                               *
//     -----------------                                                      *
//                                                                            *
//     end_ptr        - Character pointer to error in strtod                  *
//                                                                            *
//     Global Variables:                                                      *
//     -----------------                                                      *
//                                                                            *
//     Used by search, search_coeff and read_coeff                            *
//     nam            - Character*4 array used as alphanumeric symbol of      *
//                      species name read from the coefficient records        *
//     indx.h                                                                 *
//     ns           - Integer value of number of species being considered in  *
//                    the system                                              *
//     speces.h                                                               *
//     coef         - Real array of contants in empirical equations for       *
//                    thermodynamic functions                                 *
//                                                                            *
//     Constants:                                                             *
//     ---------                                                              *
//                                                                            *
//     local                                                                  *
//     FALSE            - Defines value of logical false = 0                  *
//     TRUE             - Defines value of logical true = 1                   *
//     arrays.h                                                               *
//     ibuf_blanks     - Integer value of number of blanks to set in ibuf     *
//     constants.h                                                            *
//     iblank          - Character*1 containing a blank                       *
//     coeff_length    - Integer value of length of each coefficient value    *
//     coeff_num_set   - Integer value of number of coefficients per temp set *
//     coeff_records   - Integer value of number of records per species       *
//     full_record     - Integer value of lengh of record with 5 values       *
//     num_coeff_full  - Integer value of number of values in full record     *
//     num_coeff_part  - Integer value of number of values in partial record  *
//     partial_index   - Integer value of index to partial record             *
//     partial_record  - Integer value of length of record with 4 values      *
//     second_index    - Integer value of index to second set of values       *
//     string_end      - Character containing end of string control character *
//     third_index     - Integer value of index to third set of values        *
//                                                                            *
//     Include Files:                                                         *
//     -------------                                                          *
//                                                                            *
//     arrays.h          - Contains sizes for include files                   *
//     indx.h            - Contains index variables                           *
//     iostream.h        - Contains C++ I/O routines                          *
//     speces.h          - Contains species variables                         *
//     stdlib.h          - Contains C++ standard routines                     *
//     stdio.h           - Contains FILE declaration                          *
//     string.h          - Contains C++ string routines                       *
//                                                                            *
//                                                                            *
//     External Software:                                                     *
//     -----------------                                                      *
//                                                                            *
//     init_read - Function that reads input records and returns status       *
//     strncpy   - C++ function to copy strings                               *
//     strtod    - C++ function to convert from ascii to double               *
//                                                                            *
//     Files:                                                                 *
//     -----                                                                  *
//                                                                            *
//       Input Files:                                                         *
//                                                                            *
//       therm_unit - Thermodynamic data  or                                  *
//       scratch_unit - Temporary storage for thermodynamic data              *
//                                                                            *
//       Intermediate Files:                                                  *
//                                                                            *
//       None                                                                 *
//                                                                            *
//       Output Files:                                                        *
//                                                                            *
//       output_unit - Output listing file                                    *
//       Outputs error messages to screen                                     *
//                                                                            *
//*****************************************************************************
//###
 
#include "arrays.h"
#include "indx.h"
#include <iostream.h>
#include "speces.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define FALSE 0
#define TRUE 1
 
void init_read(char *adata,
               int *eof,
               FILE *opu,
               FILE *inp_unit,
               int *empty_file,
               int *nbytes_pt);
 
 
void coeff_read(FILE *read_unit,
                FILE *output_unit,
                int *empty_file_pt,
                char *adata_pt,
                int *nbytes_pt,
                int *begin_loop_pt,
                int *eof_pt,
                char *ibuf_pt,
                char *blank_pt)
{
 
#include "constant.h"
 
extern char  nam[size_char][sub_size] ;
 
  int i;
  int j;
  int jj;
  int k;
  int kk;
  int kount ;
  int m;
  int num_coeff;
 
  char *end_ptr = "abcde";
 
//  read three sets of coefficients
 
//start coeff_read_17a
  for(m=0;m<coeff_records;m++)
  {
    num_coeff = num_coeff_full;
//  start coeff_read_17b
    if(m == 0)
    {
      j = 0;
      k = 0;
    }
    else if(m == 1) // coeff_read_17b
    {
      j = second_index;
      k = 0;
    }
    else // coeff_read_17b
    {
      j = third_index;
      k = 1;
      num_coeff = num_coeff_part;
    } // end coeff_read_17b
    kount = 0;
    *empty_file_pt = 0;
    init_read(adata_pt,eof_pt,output_unit,read_unit,
              empty_file_pt,nbytes_pt);
//  start coeff_read_18
    if(*empty_file_pt != 0)
    {
      *begin_loop_pt = FALSE ;
//    exit coeff_read_17a
      break;
    } // end coeff_read_18
 
//  start coeff_length_check_short
//    if((*nbytes_pt < full_record && m < partial_index)
//     ||(*nbytes_pt < partial_record && m == partial_index))
//    {
//      fprintf(output_unit," Coefficient record too short for:\n");
//      fprintf(output_unit,"%s\n",adata_pt);
//      cout << " Coefficient record too short for:"<<endl;
//    start output_species_name_1a
//      for(i=0;i<sub_size;i++)
//      {
//    start output_species_name_1b
//        for(jj=0;jj<size_char;jj++)
//        {
//          cout << nam[jj][i];
//        } // end output_species_name_1b
//      } // end output_species_name_1a
//      cout <<endl;
//      *begin_loop_pt = FALSE ;
//      *eof_pt = 1;
//    exit coeff_read_17a
//      break;
//    } // end coeff_length_check_short
 
//  start coeff_length_check_long
    if((*nbytes_pt > full_record && m < partial_index)
     ||(*nbytes_pt > partial_record && m == partial_index))
    {
      fprintf(output_unit," Warning - Coefficient record too long for:\n");
      fprintf(output_unit,"%s\n",adata_pt);
      cout << " Warning - Coefficient record too long for:"<<endl;
//    start output_species_name_1a
      for(i=0;i<sub_size;i++)
      {
//      start output_species_name_1b
        for(jj=0;jj<size_char;jj++)
        {
          cout << nam[jj][i];
        } // end output_species_name_1b
      } // end output_species_name_1a
      cout << endl;
//    start reset_nbytes_1
      if(m < partial_index)
      {
        *nbytes_pt = full_record;
      } // end reset_nbytes_1
//    start reset_nbytes_2
      if(m == partial_index)
      {
        *nbytes_pt = partial_record;
      } // end reset_nbytes_2
    } // end coeff_length_check_long
//  start coeff_read_18a
    for(i=0;i<num_coeff;i++)
    {
      strncpy(ibuf_pt,blank_pt,ibuf_blanks);
//    start get_coefficients
      if((i+1) < num_coeff)
      {
        strncpy(ibuf_pt,(adata_pt+kount),coeff_length);
      }
      else // get_coefficients
      {
        strncpy(ibuf_pt,adata_pt+kount,
                *nbytes_pt - (kount+1));
      } // end get_coefficients
      *(ibuf_pt+coeff_length) = string_end;
//    start coef_find_blanks
      for(kk=(coeff_length-1);kk>=0;kk=kk-1)
      {
//       start coef_found_nonblank
         if(*(ibuf_pt+kk) != iblank)
         {
//         exit coef_find_blanks
           break;
         } // end coef_found_nonblank
      } // end coef_find_blanks
//    start find_missing_E_plus
      for(jj=0;jj<coeff_length;jj++)
      {
//      start find_E
        if(*(ibuf_pt+jj)== 'E'
        || *(ibuf_pt+jj)== 'e')
        {
//        start replace_blank_with_plus
          if(*(ibuf_pt+(jj+1)) == ' ')
          {
            *(ibuf_pt+(jj+1)) = '+';
            break;
          } //  end replace_blank_with_plus
        } // end find_E
 
      } // end find_missing_E_pluw
      coef[k][j][ns] = strtod(ibuf_pt,&end_ptr);
//    start coef_error
      if(end_ptr != (ibuf_pt+(kk+1)))
      {
        fprintf(output_unit," Error in coefficient value for:\n");
        fprintf(output_unit,"%s\n",adata_pt);
        cout << " Error in coefficient value for:"<<endl;
//      start output_species_name_1a
        for(i=0;i<sub_size;i++)
        {
//        start output_species_name_1b
          for(jj=0;jj<size_char;jj++)
          {
            cout << nam[jj][i];
          } // end output_species_name_1b
        } // end output_species_name_1a
        cout << endl;
        *eof_pt = 1;
//      exit coeff_read_18a
        break;