parser.h

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 */

#ifndef PARSER_H_
#define PARSER_H_

#include <stdio.h>
#include <map>

const char * nWord(const char *chKey, 
            const char *chCard);

class Parser;

typedef void (*OptionParser)(Parser &);

struct CloudyCommand {
        const char *name;
        OptionParser action;
};

bool isBoundaryChar(char c);

class Parser
{
        char m_card[INPUT_LINE_LENGTH],
                m_card_raw[INPUT_LINE_LENGTH];
        long int m_len;
        const char * m_ptr;
        bool m_lgEOL;
        const CloudyCommand * const m_Commands;
        std::map<string,double> m_symtab;
public:
        long int m_nqh, m_nInitFile;
        bool m_lgDSet, m_lgEOF;

        explicit Parser(void) : m_Commands(NULL)
        {
                init();
        }
        explicit Parser(const CloudyCommand *commands) : m_Commands(commands) 
        {
                init();
        }
private:
        void init(void)
        {
                m_nqh = m_nInitFile = 0;
                m_lgDSet = m_lgEOF = false;
                setline("");
        }
        void newlineProcess(void)
                {
                        strncpy(m_card,m_card_raw,INPUT_LINE_LENGTH);
                        ::caps(m_card);
                        m_len = INPUT_LINE_LENGTH;
                        m_ptr = m_card;
                        m_lgEOL = false;
                }
public:
        bool getline(void);
        void setline(const char * const card)
                {
                        ASSERT(INPUT_LINE_LENGTH > 0);
                        ASSERT(strlen(card) < (unsigned) INPUT_LINE_LENGTH);
                        strncpy(m_card_raw,card,INPUT_LINE_LENGTH);
                        newlineProcess();
                }

        void set_point(long int ipnt)
        {
                m_ptr = m_card+ipnt;
        }
        const char * nWord(const char *chKey) const;
private:
        char chPoint( void ) const
        {
                return *m_ptr;
        }
public:
        long int GetElem( void ) const;
        double FFmtRead( void );
        double getNumberPlain( const char *chDesc );
        double getNumberCheck( const char *chDesc );
        double getNumberDefault( const char *chDesc, double fdef );
        double getNumberCheckLogLinNegImplLog( const char *chDesc );
        double getNumberCheckAlwaysLog( const char *chDesc );
        double getNumberCheckAlwaysLogLim( const char *chDesc, double flim );
        double getNumberDefaultAlwaysLog( const char *chDesc, double fdef );
        double getNumberDefaultNegImplLog( const char *chDesc, double fdef );
        bool lgEOL(void) const
        {
                return m_lgEOL;
        }
        void setEOL(bool val)
        {
                m_lgEOL = val;
        }
        NORETURN void NoNumb(const char *chDesc) const;
private:
        int nMatch1(const char *chKey) const
        {
                const char *p=chKey;

                while (isspace(*p))
                        ++p;

                for (const char *q=p; *q; ++q)
                        ASSERT(!islower(*q));

                if ( !isBoundaryChar(*p))
                {
                        const char *q = ::nWord(p, m_card);
                        if (NULL == q)
                                return 0;
                        else
                                return q-m_card+1;
                }
                else
                {
                        // If the keyword starts with a member of the boundary character
                        // set, can't require it to be preceded by one so revert to explicit
                        // matching
                        return ::nMatch(chKey, m_card);
                }
        }               
public:
        bool nMatch(const char *chKey) const
        {
                return nMatch1(chKey) != 0;
        }
        bool GetParam(const char *chKey, double *val)
        {
                int i = nMatch1(chKey);
                if (i > 0) {
                        m_ptr = m_card+i-1;
                        *val = FFmtRead();
                }
                return i>0;
        }
        bool GetRange(const char *chKey, double *val1, double *val2)
        {
                int i = nMatch1(chKey);
                if (i > 0) {
                        m_ptr = m_card+i-1;
                        *val1 = FFmtRead();
                        *val2 = FFmtRead();
                }
                return i>0;
        }
        bool nMatchErase(const char *chKey)
        {
                const char *p=chKey;
                while (isspace(*p))
                        ++p;
                int i = nMatch1(p);
                bool found = (i != 0);
                if(found) 
                {
                        char *ptr = m_card+i-1;
                        const long len = strlen(p);
                        /* erase this keyword, it upsets FFmtRead */
                        for (long i=0; i<len; ++i)
                        {
                                ptr[i] = ' ';
                        }
                }               
                return found;
        }
        int strcmp(const char *s2)
        {
                size_t len = strlen(s2);
                int val = ::strncmp(m_card, s2, len);
                if (val == 0)
                {
                        m_ptr = m_card+len;
                }
                return val;
        }
        bool Command(const char *name, OptionParser doOpts)
        {
                bool lgFound = (this->strcmp(name) == 0);
                if ( lgFound )
                        (*doOpts)(*this);
                return lgFound;
        }
        bool isComment(void) const;
        bool isCommandComment(void) const;
        bool isVar(void) const;
        std::string getVarName(void);
        void doSetVar(void);
        void echo(void) const;
        bool last(void) const
        {
                return m_lgEOF || m_card[0] == ' ';
        }
        int PrintLine(FILE *fp) const
        {
                return fprintf( fp, " ==%-.80s==\n", m_card_raw);
        }
        NORETURN void CommandError(void) const;
        int GetQuote(  char *chLabel, bool lgABORT )
        {
                return ::GetQuote(chLabel, m_card, m_card_raw, lgABORT);
        }
        const char *StandardEnergyUnit(void) const;
        string StandardFluxUnit(void) const;
        string getCommand(long i) 
                {
                        m_ptr = m_card+i;
                        return string(m_card).substr(0,i);
                }
        string getRawTail()
                {
                        return string(m_card_raw+(m_ptr-m_card));
                }
        void help(FILE *fp) const;
        double getWave();
        double getWaveOpt();
        void getLineID(char *LabelBuf, realnum *wave);
};

template <typename V>
class KeyAction {
        const char * const m_keyword;
        V m_action;
public:
        KeyAction(const char *keyword, const V &action) :
                m_keyword(keyword), m_action(action) {}
                
        const char *key(void) const
        {
                return m_keyword;
        }
        void operator()(realnum *v) const
        {
                m_action(v);
        }
};

template <typename V>
inline KeyAction<V> MakeKeyAction(const char *keyword, const V &action)
{
        return KeyAction<V>(keyword, action);
}

class UnitConverter
{
        const realnum m_unit;
public:
        UnitConverter ( double unit ) : m_unit((realnum)unit) {}
                
        void operator()( realnum *t ) const
        {
                *t *= m_unit;
        }
};

template <typename T, typename V>
bool parserProcess(Parser &p, T *list, 
                                                 unsigned long nlist, V *value)
{
        bool lgFound = false;
        for (unsigned long option=0; option < nlist; ++option)
        {
                if( p.nWord( list[option].key() ) )
                {
                        list[option]( value );
                        lgFound = true;
                        break;
                }
        }
        return lgFound;
}

void ParseCosmicRays( Parser &p );

void ParseCosmology( Parser &p );

void ParseAbundancesNonSolar(Parser &p);

void ParseAbundances(Parser &p);

void ParseDont(Parser &p);

void ParseSave(Parser &p);

void parse_save_line(Parser &p, 
  /* true, return rel intensity, false, log of luminosity or intensity I */
  bool lgLog3,
  char *chHeader);

void parse_save_average( 
        Parser &p,
        /* the file we will write to */
        long int ipPun, 
        char *chHeader);

void parse_save_colden(
        Parser &p,
  /* the header for the file, a list of identifications */
        char chHeader[] );

void Parse_Save_Line_RT(Parser &p);

void ParseAge(Parser &p);

void ParseAgn(Parser &p);

void ParseState(Parser &p);

void ParseBlackbody(Parser &p);                                 

void ParseCompile(Parser &p );

void ParseConstant(Parser &p);

void ParseDLaw(Parser &p );

void ParseTLaw(Parser &p);

void ParseDrive(Parser &p );

void ParseGrain(Parser &p);

void ParseFluc(Parser &p);

void ParseHDEN(Parser &p);

void ParseAtomISO(long ipISO, Parser &p);

void ParseAtomH2(Parser &p );

void ParseGrid(Parser &p);

void ParseInit(Parser &p);

void ParseInterp(Parser &p);

void ParseIonParI(Parser &p);

void ParseIonParX(Parser &p);
void ParseIonPar(Parser &p,
                                          char chType);

void ParseNorm(Parser &p);

void ParseOptimize(Parser &p);

void ParsePrint(Parser &p );

void ParseRadius(Parser &p);

void ParseSet(Parser &p);

void ParseTable(Parser &p);

void ParseTrace(Parser &p);

/*ParseExtinguish parse the extinguish command */
void ParseExtinguish( Parser &p );

/*ParseIlluminate parse the illuminate command */
void ParseIlluminate( Parser &p );

/*ParseCaseB - parse the Case B command */
void ParseCaseB(Parser &p );

void ParseTest(Parser &p);

void ParseAbsMag(Parser &p);

void ParseBackgrd(Parser &p);

void ParseCoronal(Parser &p);

void ParseElement(Parser &p);

void ParseCMB(double z, 
  long int *nqh);

void ParseF_nu(
  Parser &p, 
  const char *chType, 
  bool lgNU2);

void ParseGlobule(Parser &p);

void ParseRangeOption(Parser &p);

void ParseMap(Parser &p);

void ParseMetal(Parser &p);

void ParsePrtLineSum(Parser &p);

void ParsePlot(Parser &p);

void ParsePowerlawContinuum(Parser &p);

void ParseRatio(Parser &p);

void ParseSphere(Parser &p);

void ParseStop(Parser &p);

void ParseCrashDo(Parser &p);


#endif // _PARSER_H_