/home66/gary/public_html/cloudy/c13_branch/source/input.cpp

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2013 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */
/* input_readarray read input commands from array where images are stored *
 * returns chCard, which will have <=80 characters before eol    *
 * line image is up and low case                                 */
/*input_init initial input_readarray array for storing line images at start of calculation */
/*lgInputComment - parse comment - check if argument is comment string */
#include "cddefines.h"
#include "trace.h"
#include "input.h"

t_input input;

/*lgInputComment - parse comment - check if argument is comment string, 
 * either upper or lower case -
 * returns true if line is a comment, false if not 
 * a comment is any line starting with "C ", *, %, //, or # */
bool lgInputComment( const char *chLine )
{
        bool lgReturn;

        DEBUG_ENTRY( "lgInputComment()" );

        /* should not call this routine with null line */
        if( chLine[0] == 0 )
                TotalInsanity();

        /* first case - the special characters that can start a line */
        if( chLine[0] == '#' || chLine[0] == '*' || chLine[0] == '%' || chLine[0] == ' ' )
        {
                lgReturn = true;
        }
        else if( strncmp(chLine,"//", 2 ) == 0 )
        {
                lgReturn = true;
        }
        /* second case is line that starts with c */
        else if( chLine[0] == 'C' || chLine[0] == 'c' )
        {
                /* line starts with C, could be a command or a comment,
                 * if a comment then line is "C ", but there could be a newline '\n')
                 * or carriage return '\r' in the [1] position 
                 * '\r' is carriage return, happens on cygwin gcc */
                if( chLine[1] == '\n' || chLine[1] == ' ' || chLine[1] == '\r' ) 
                {
                        lgReturn = true;
                }
                else
                {
                        lgReturn = false;
                }
        }
        else
        {
                lgReturn = false;
        }
        /*fprintf(ioQQQ,"DEBUG %c \n", TorF(lgReturn ) );*/

        return lgReturn;
}

/*input_init initial input_readarray array for storing line images at start of calculation */
void t_input::init(void)
{

        DEBUG_ENTRY( "t_input::init()" );

        /* this sub must be called before calling READAR to get line images
         * it simply sets the pointer to set up reading the images
         * */
        if( iReadWay > 0 )
        {
                /* this is usual case, read from the start of array, the commands */
                nRead = -1;
        }
        else if( iReadWay < 0 )
        {
                /* this is special case where we read from end of array, the ini file */
                /* save the current counter so we can reset it when done */
                nReadSv = nRead;

                /* and set current counter to the bottom of the stack */
                nRead = NKRD;
        }

        return;
}

void t_input::echo( FILE *ipOUT)
{
        char chCard[INPUT_LINE_LENGTH];

        /* start the file with the input commands */
        init();

        bool lgEOF = false;
        while( !lgEOF )
        {
                readarray(chCard,&lgEOF);
                if( !lgEOF )
                {
                        char chCAPS[INPUT_LINE_LENGTH];
                        strcpy( chCAPS , chCard );
                        caps( chCAPS );
                        /* keyword HIDE means to hide the command - do not print it */
                        if( !nMatch( "HIDE" , chCAPS ) )
                                fprintf( ipOUT, "%s\n", chCard );
                }
        }

}
/*input_readarray read input commands from array where images are stored *
 * returns chCard, which will have <=80 characters before eol    */
void t_input::readarray(char *chCard, 
  bool *lgEOF)
{
        long int last;

        DEBUG_ENTRY( "t_input::readarray()" );

        if( iReadWay > 0 )
        {
                /* usual case, reading commands from start of array
                 * nRead points to one plus the array element with the next line, it is
                 * one on the first call, which references line[0] */
                ++nRead;

                /* nSave points to the last line array element that was saved,
                 * so it is one less than the number of lines read.  the last element
                 * containing a line image is [input.nSave].  There is a -1 for
                 * nRead to bring it onto the same c counting scale as nSave */
                if( nRead > nSave )
                {
                        *lgEOF = true;
                }
                else
                {
                        /* get the line image */
                        strcpy( chCard, chCardSav[nRead] );

                        *lgEOF = false;
                }
        }
        else
        {
                /* this is special case of reading cloudy.ini file, 
                 * nRead was set to 1+last image in input_init, so first time
                 * we get here it is very large.  decrement counter from end of file */
                nRead -= 1;

                /* last one with real data is NKRD+1-nSaveIni */
                last = NKRD - nSaveIni;

                /* this read is eof eof */
                if( nRead < last )
                {
                        /* reset counter so we read in the proper direction */
                        iReadWay = 1;
                        /* pointer to next line to read.  this is on the scale where nRead-1
                         * is the actual array element */
                        nRead = nReadSv+1;
                }

                /* check if we hit eof while reading in forward direction */
                if( iReadWay == 1 && nRead > nSave )
                {
                        *lgEOF = true;
                }
                else
                {
                        strcpy( chCard, chCardSav[nRead] );

                        /* did not hit eof */
                        *lgEOF = false;
                }
        }

        /* if any "trace" appeared on a command line, then this flag was set
         * so print the input command before it is parsed */
        if( trace.lgTrace )
        {
                fprintf( ioQQQ, "t_input::readarray returns=%s=\n",chCard );
        }

        return;
}

void input_readvector(const char* chFile, 
                      double vector[],    
                      long n,             
                      bool* lgEOF)        
{
        DEBUG_ENTRY( "input_readvector()" );

        fstream ioDATA;
        open_data( ioDATA, chFile, mode_r, AS_LOCAL_ONLY );

        for( long i=0; i < n; ++i )
                ioDATA >> vector[i];

        *lgEOF = !ioDATA.good();
        return;
}

---