copasi::COptionParser Class Reference

#include <COptionParser.h>

Collaboration diagram for copasi::COptionParser:

Public Member Functions
	COptionParser (void)
	default constructor More...
void	finalize (void)
	finalize all parsing (eg. check for mandatory options) More...
const option_locations &	get_locations (void) const
	get the main option locations More...
const std::vector< std::string > &	get_non_options (void) const
	get a list of nonoptions from the command line More...
const options &	get_options (void) const
	get the main options More...
void	parse (int argc, char *argv[], bool call_finalize=true)
	parse the command line More...
void	parse (const char *fileName)
	parse a file More...

Private Types
enum	opsource { source_cl, source_cf }
enum	options_enum {   option_ConfigDir, option_ConfigFile, option_CopasiDir, option_Home,   option_Tmp, option_Verbose, option_NoLogo, option_License,   option_Validate, option_Save, option_ImportSBML, option_ExportSBML,   option_SBMLSchema, option_ExportBerkeleyMadonna, option_ExportC, option_ExportXPPAUT,   option_MaxTime }
enum	parser_state { state_option, state_value, state_consume }

Private Member Functions
void	parse_element (const char *element, int position, opsource source)
void	parse_long_option (const char *option, int position, opsource source)
void	parse_short_option (char option, int position, opsource source)
void	parse_value (const char *value)

Private Attributes
option_locations	locations_
std::vector< std::string >	non_options_
enum copasi::COptionParser::options_enum	openum_
options	options_
enum copasi::COptionParser::parser_state	state_

Detailed Description

the COptionParser class is the main command line parsing class. You can control the name of it using the cxx_class variable.

Definition at line 166 of file COptionParser.h.

Member Enumeration Documentation

enum copasi::COptionParser::opsource

private

Enumerator
source_cl
source_cf

Definition at line 224 of file COptionParser.h.

  {
    source_cl,
    source_cf
  };

enum copasi::COptionParser::options_enum

private

Enumerator
option_ConfigDir
option_ConfigFile
option_CopasiDir
option_Home
option_Tmp
option_Verbose
option_NoLogo
option_License
option_Validate
option_Save
option_ImportSBML
option_ExportSBML
option_SBMLSchema
option_ExportBerkeleyMadonna
option_ExportC
option_ExportXPPAUT
option_MaxTime

Definition at line 196 of file COptionParser.h.

  {
    option_ConfigDir,
    option_ConfigFile,
    option_CopasiDir,
    option_Home,
    option_Tmp,
    option_Verbose,
    option_NoLogo,
    option_License,
    option_Validate,
    option_Save,
    option_ImportSBML,
    option_ExportSBML,
    option_SBMLSchema,
    option_ExportBerkeleyMadonna,
    option_ExportC,
    option_ExportXPPAUT,
    option_MaxTime

#ifdef COPASI_SEDML
   , option_ImportSEDML
#endif
  } openum_;

enum copasi::COptionParser::parser_state

private

Enumerator
state_option
state_value
state_consume

Definition at line 221 of file COptionParser.h.

{state_option, state_value, state_consume } state_;

Constructor & Destructor Documentation

copasi::COptionParser::COptionParser

(

void

)

default constructor

Definition at line 74 of file COptionParser.cpp.

References locations_.

    : state_(state_option)
{
  memset(&locations_, 0, sizeof(locations_));
}

Member Function Documentation

void copasi::COptionParser::finalize

(

void

)

finalize all parsing (eg. check for mandatory options)

Definition at line 185 of file COptionParser.cpp.

{
  if (state_ == state_value)
    {
      switch (openum_)
        {
          case option_ConfigDir:
            throw option_error("missing value for 'configdir' option");
          case option_ConfigFile:
            throw option_error("missing value for 'configfile' option");
          case option_CopasiDir:
            throw option_error("missing value for 'copasidir' option");
          case option_ExportBerkeleyMadonna:
            throw option_error("missing value for 'exportBerkeleyMadonna' option");
          case option_ExportC:
            throw option_error("missing value for 'exportC' option");
          case option_ExportSBML:
            throw option_error("missing value for 'exportSBML' option");
          case option_ExportXPPAUT:
            throw option_error("missing value for 'exportXPPAUT' option");
          case option_Home:
            throw option_error("missing value for 'home' option");
          case option_ImportSBML:
            throw option_error("missing value for 'importSBML' option");
          case option_License:
            throw option_error("missing value for 'license' option");
          case option_MaxTime:
            throw option_error("missing value for 'maxTime' option");
          case option_NoLogo:
            throw option_error("missing value for 'nologo' option");
          case option_SBMLSchema:
            throw option_error("missing value for 'SBMLSchema' option");
          case option_Save:
            throw option_error("missing value for 'save' option");
          case option_Tmp:
            throw option_error("missing value for 'tmp' option");
          case option_Validate:
            throw option_error("missing value for 'validate' option");
          case option_Verbose:
            throw option_error("missing value for 'verbose' option");
        }
    }
}

const option_locations& copasi::COptionParser::get_locations ( void  ) const

inline

get the main option locations

Definition at line 190 of file COptionParser.h.

References locations_.

  {return locations_;}

const std::vector<std::string>& copasi::COptionParser::get_non_options ( void  ) const

inline

get a list of nonoptions from the command line

Definition at line 182 of file COptionParser.h.

References non_options_.

Referenced by COptions::init().

  {return non_options_;}

const options& copasi::COptionParser::get_options ( void  ) const

inline

get the main options

Definition at line 186 of file COptionParser.h.

References options_.

Referenced by COptions::init().

  {return options_;}

void copasi::COptionParser::parse	(	int	argc,
		char *	argv[],
		bool	call_finalize = true
	)

parse the command line

Definition at line 80 of file COptionParser.cpp.

Referenced by COptions::init(), and main().

{
  int i = 1;

#ifdef Darwin

  if (argc > 1)
    {
      std::string tmp(argv[1]);

      if (!tmp.compare(0, 4, "-psn")) i = 2;
    }

#endif // Darwin

  for (; i < argc; ++i) parse_element(argv[i], i, source_cl);

  if (call_finalize) finalize();
}

void copasi::COptionParser::parse

(

const char *

fileName

)

parse a file

Definition at line 100 of file COptionParser.cpp.

{
  int LineCounter = 0;
  std::string Line;
  std::string Option;
  std::string Value;
  std::string::size_type pos;
  std::ifstream File(fileName);

  if (File.fail())
    {
      std::ostringstream error;
      error << "error opening file: '" << fileName << "'";
      errno = ENOENT;

      throw option_error(error.str());
    }

  while (true)
    {
      try
        {
          std::getline(File, Line);
          LineCounter++;

          if (File.eof()) break;

          if (File.fail())
            {
              std::ostringstream error;
              error << "unknown problem";

              throw option_error(error.str());
            }

#ifndef WIN32
          /* Take care of dos style line ending under UNIX */
          /* A case where MS has the better implementation */
          pos = Line.length();
          (pos < 1) ? 0 : pos--;

          if (Line[pos] == 0xd) Line.erase(pos);

#endif  // not WIN32

          // eat leading spaces
          Line.erase(0, Line.find_first_not_of(' '));

          // skip comments and empty lines
          if (Line.length() == 0 || Line[0] == '#') continue;

          // find first position of '=' or ':'
          pos = Line.find_first_of(":=");

          Option = "--" + Line.substr(0, pos);
          Option.erase(Option.find_last_not_of(' ') + 1);

          parse_element(Option.c_str(), 0, source_cf);

          if (pos != std::string::npos) // We have a '='
            {
              Value = Line.substr(pos + 1);
              Value.erase(0, Value.find_first_not_of(' '));
              Value.erase(Value.find_last_not_of(' ') + 1);

              if (Value.length()) parse_element(Value.c_str(), 0, source_cf);
            }

          finalize();
        }

      catch (copasi::option_error &e)
        {
          std::ostringstream error;
          error << "error reading file: '" << fileName << "(" << LineCounter
          << ")': " << e.what();

          throw option_error(error.str());
        }
    }

  File.clear();
  File.close();
}

void copasi::COptionParser::parse_element ( const char *  element, int  position, opsource  source  )

private

Definition at line 229 of file COptionParser.cpp.

{
  size_t length = strlen(element);

  switch (state_)
    {
      case state_consume:
        non_options_.push_back(element);
        break;
      case state_option:

        if (length >= 2 && element[0] == '-' && element[1] == '-')
          {
            if (length == 2) {state_ = state_consume; return;}

            element += 2;
            const char *value = element;

            while (*value != 0 && *value != '=') ++value;

            if (*value == '=')
              {
                std::string selement(element, value - element), svalue(++value);

                parse_long_option(selement.c_str(), position, source);

                if (state_ != state_value)
                  {
                    std::string error("the '"); error += element; error += "' option does not take a value";
                    throw option_error(error);
                  }

                parse_value(svalue.c_str());
                state_ = state_option;
              }
            else
              {
                parse_long_option(element, position, source);
              }
          }
        else if (length >= 2 && element[0] == '-')
          {
            ++element;

            if (length > 2)
              {
                while (*element != 0)
                  {
                    parse_short_option(*element, position, source);
                    ++element;

                    if (state_ == state_value && *element == '=')
                      {
                        parse_value(++element);
                        state_ = state_option;
                        break;
                      }
                    else if (state_ == state_value) finalize();
                  }
              }
            else
              {
                parse_short_option(*element, position, source);
              }
          }
        else
          {
            non_options_.push_back(element);
          }

        break;
      case state_value:
        parse_value(element);
        state_ = state_option;
        break;
    }
}

void copasi::COptionParser::parse_long_option ( const char *  option, int  position, opsource  source  )

private

Definition at line 390 of file COptionParser.cpp.

References copasi::autothrow_help.

{
  option = expand_long_name(option);

  if (strcmp(option, "SBMLSchema") == 0)
    {
      if (source != source_cl) throw option_error("the 'SBMLSchema' option is only allowed on the command line");

      if (locations_.SBMLSchema)
        {
          throw option_error("the 'SBMLSchema' option is only allowed once");
        }

      openum_ = option_SBMLSchema;
      locations_.SBMLSchema = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "configdir") == 0)
    {
      if (source != source_cl) throw option_error("the 'configdir' option is only allowed on the command line");

      if (locations_.ConfigDir)
        {
          throw option_error("the 'configdir' option is only allowed once");
        }

      openum_ = option_ConfigDir;
      locations_.ConfigDir = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "configfile") == 0)
    {
      if (source != source_cl) throw option_error("the 'configfile' option is only allowed on the command line");

      if (locations_.ConfigFile)
        {
          throw option_error("the 'configfile' option is only allowed once");
        }

      openum_ = option_ConfigFile;
      locations_.ConfigFile = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "copasidir") == 0)
    {
      if (source != source_cl) throw option_error("the 'copasidir' option is only allowed on the command line");

      if (locations_.CopasiDir)
        {
          throw option_error("the 'copasidir' option is only allowed once");
        }

      openum_ = option_CopasiDir;
      locations_.CopasiDir = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "exportBerkeleyMadonna") == 0)
    {
      if (source != source_cl) throw option_error("the 'exportBerkeleyMadonna' option is only allowed on the command line");

      if (locations_.ExportBerkeleyMadonna)
        {
          throw option_error("the 'exportBerkeleyMadonna' option is only allowed once");
        }

      openum_ = option_ExportBerkeleyMadonna;
      locations_.ExportBerkeleyMadonna = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "exportC") == 0)
    {
      if (source != source_cl) throw option_error("the 'exportC' option is only allowed on the command line");

      if (locations_.ExportC)
        {
          throw option_error("the 'exportC' option is only allowed once");
        }

      openum_ = option_ExportC;
      locations_.ExportC = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "exportSBML") == 0)
    {
      if (source != source_cl) throw option_error("the 'exportSBML' option is only allowed on the command line");

      if (locations_.ExportSBML)
        {
          throw option_error("the 'exportSBML' option is only allowed once");
        }

      openum_ = option_ExportSBML;
      locations_.ExportSBML = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "exportXPPAUT") == 0)
    {
      if (source != source_cl) throw option_error("the 'exportXPPAUT' option is only allowed on the command line");

      if (locations_.ExportXPPAUT)
        {
          throw option_error("the 'exportXPPAUT' option is only allowed once");
        }

      openum_ = option_ExportXPPAUT;
      locations_.ExportXPPAUT = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "home") == 0)
    {
      if (source != source_cl) throw option_error("the 'home' option is only allowed on the command line");

      if (locations_.Home)
        {
          throw option_error("the 'home' option is only allowed once");
        }

      openum_ = option_Home;
      locations_.Home = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "importSBML") == 0)
    {
      if (source != source_cl) throw option_error("the 'importSBML' option is only allowed on the command line");

      if (locations_.ImportSBML)
        {
          throw option_error("the 'importSBML' option is only allowed once");
        }

      openum_ = option_ImportSBML;
      locations_.ImportSBML = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "license") == 0)
    {
      if (source != source_cl) throw option_error("the 'license' option is only allowed on the command line");

      if (locations_.License)
        {
          throw option_error("the 'license' option is only allowed once");
        }

      openum_ = option_License;
      locations_.License = position;
      options_.License = !options_.License;
      return;
    }
  else if (strcmp(option, "maxTime") == 0)
    {
      if (source != source_cl) throw option_error("the 'maxTime' option is only allowed on the command line");

      if (locations_.MaxTime)
        {
          throw option_error("the 'maxTime' option is only allowed once");
        }

      openum_ = option_MaxTime;
      locations_.MaxTime = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "nologo") == 0)
    {
      source = source; // kill compiler unused variable warning

      if (locations_.NoLogo)
        {
          throw option_error("the 'nologo' option is only allowed once");
        }

      openum_ = option_NoLogo;
      locations_.NoLogo = position;
      options_.NoLogo = !options_.NoLogo;
      return;
    }
  else if (strcmp(option, "save") == 0)
    {
      source = source; // kill compiler unused variable warning

      if (locations_.Save)
        {
          throw option_error("the 'save' option is only allowed once");
        }

      openum_ = option_Save;
      locations_.Save = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "tmp") == 0)
    {
      source = source; // kill compiler unused variable warning

      if (locations_.Tmp)
        {
          throw option_error("the 'tmp' option is only allowed once");
        }

      openum_ = option_Tmp;
      locations_.Tmp = position;
      state_ = state_value;
      return;
    }
  else if (strcmp(option, "validate") == 0)
    {
      source = source; // kill compiler unused variable warning

      if (locations_.Validate)
        {
          throw option_error("the 'validate' option is only allowed once");
        }

      openum_ = option_Validate;
      locations_.Validate = position;
      options_.Validate = !options_.Validate;
      return;
    }
  else if (strcmp(option, "verbose") == 0)
    {
      source = source; // kill compiler unused variable warning

      if (locations_.Verbose)
        {
          throw option_error("the 'verbose' option is only allowed once");
        }

      openum_ = option_Verbose;
      locations_.Verbose = position;
      options_.Verbose = !options_.Verbose;
      return;
    }
  else if (source == source_cl && strcmp(option, "help") == 0)
    {
      throw autoexcept(autothrow_help, const_usage);
    }

  std::string error("unknown option '"); error += option; error += "'";
  throw option_error(error);
}

void copasi::COptionParser::parse_short_option ( char  option, int  position, opsource  source  )

private

Definition at line 307 of file COptionParser.cpp.

References copasi::autothrow_help.

{
  switch (option)
    {
      case 'c':

        if (source != source_cl) throw option_error("the 'copasidir' option can only be used on the command line");

        if (locations_.CopasiDir)
          {
            throw option_error("the 'copasidir' option is only allowed once");
          }

        openum_ = option_CopasiDir;
        state_ = state_value;
        locations_.CopasiDir = position;
        return;
      case 'e':

        if (source != source_cl) throw option_error("the 'exportSBML' option can only be used on the command line");

        if (locations_.ExportSBML)
          {
            throw option_error("the 'exportSBML' option is only allowed once");
          }

        openum_ = option_ExportSBML;
        state_ = state_value;
        locations_.ExportSBML = position;
        return;
      case 'i':

        if (source != source_cl) throw option_error("the 'importSBML' option can only be used on the command line");

        if (locations_.ImportSBML)
          {
            throw option_error("the 'importSBML' option is only allowed once");
          }

        openum_ = option_ImportSBML;
        state_ = state_value;
        locations_.ImportSBML = position;
        return;
      case 's':
        source = source; // kill compiler unused variable warning

        if (locations_.Save)
          {
            throw option_error("the 'save' option is only allowed once");
          }

        openum_ = option_Save;
        state_ = state_value;
        locations_.Save = position;
        return;
      case 't':
        source = source; // kill compiler unused variable warning

        if (locations_.Tmp)
          {
            throw option_error("the 'tmp' option is only allowed once");
          }

        openum_ = option_Tmp;
        state_ = state_value;
        locations_.Tmp = position;
        return;
      case 'h':

        if (source != source_cl) break;

        throw autoexcept(autothrow_help, const_usage);
      case '?':

        if (source != source_cl) break;

        throw autoexcept(autothrow_help, const_usage);
    }

  std::string error("unknown option: '"); error += option; error += "'";
  throw option_error(error);
}

void copasi::COptionParser::parse_value ( const char *  value )

private

Definition at line 641 of file COptionParser.cpp.

References copasi::SBMLSchema_L1V1, copasi::SBMLSchema_L1V2, copasi::SBMLSchema_L2V1, copasi::SBMLSchema_L2V2, copasi::SBMLSchema_L2V3, copasi::SBMLSchema_L2V4, and copasi::SBMLSchema_L3V1.

{
  switch (openum_)
    {
      case option_ConfigDir:
      {
        options_.ConfigDir = value;
      }
      break;
      case option_ConfigFile:
      {
        options_.ConfigFile = value;
      }
      break;
      case option_CopasiDir:
      {
        options_.CopasiDir = value;
      }
      break;
      case option_ExportBerkeleyMadonna:
      {
        options_.ExportBerkeleyMadonna = value;
      }
      break;
      case option_ExportC:
      {
        options_.ExportC = value;
      }
      break;
      case option_ExportSBML:
      {
        options_.ExportSBML = value;
      }
      break;
      case option_ExportXPPAUT:
      {
        options_.ExportXPPAUT = value;
      }
      break;
      case option_Home:
      {
        options_.Home = value;
      }
      break;
      case option_ImportSBML:
      {
        options_.ImportSBML = value;
      }
      break;
      case option_License:
        break;
      case option_MaxTime:
      {
        char *endptr; int tmp = std::strtol(value, &endptr, 0);

        while (*endptr != 0 && std::isspace(*endptr)) ++endptr;

        if (*endptr != 0)
          {
            std::string error("invalid integer value '"); error += value; error += "'";
            throw option_error(error);
          }

        if (tmp < 0)
          {
            throw option_error("integer value out of range, 'maxTime' min is 0");
          }

        options_.MaxTime = tmp;
      }
      break;
      case option_NoLogo:
        break;
      case option_SBMLSchema:
      {
        SBMLSchema_enum evalue;

        if (strcmp(value, "L1V1") == 0)
          {
            evalue = SBMLSchema_L1V1;
          }
        else if (strcmp(value, "L1V2") == 0)
          {
            evalue = SBMLSchema_L1V2;
          }
        else if (strcmp(value, "L2V1") == 0)
          {
            evalue = SBMLSchema_L2V1;
          }
        else if (strcmp(value, "L2V2") == 0)
          {
            evalue = SBMLSchema_L2V2;
          }
        else if (strcmp(value, "L2V3") == 0)
          {
            evalue = SBMLSchema_L2V3;
          }
        else if (strcmp(value, "L2V4") == 0)
          {
            evalue = SBMLSchema_L2V4;
          }
        else if (strcmp(value, "L3V1") == 0)
          {
            evalue = SBMLSchema_L3V1;
          }
        else
          {
            std::string error("'"); error += value; error += "' is an invalid value for the 'SBMLSchema' option";
            throw option_error(error);
          }

        options_.SBMLSchema = evalue;
      }
      break;
      case option_Save:
      {
        options_.Save = value;
      }
      break;
      case option_Tmp:
      {
        options_.Tmp = value;
      }
      break;
      case option_Validate:
        break;
      case option_Verbose:
        break;
    }
}

Member Data Documentation

option_locations copasi::COptionParser::locations_

private

Definition at line 194 of file COptionParser.h.

Referenced by COptionParser(), and get_locations().

std::vector<std::string> copasi::COptionParser::non_options_

private

Definition at line 222 of file COptionParser.h.

Referenced by get_non_options().

enum copasi::COptionParser::options_enum copasi::COptionParser::openum_

private

options copasi::COptionParser::options_

private

Definition at line 193 of file COptionParser.h.

Referenced by get_options().

enum copasi::COptionParser::parser_state copasi::COptionParser::state_

private

---

The documentation for this class was generated from the following files:

• COptionParser.h
• COptionParser.cpp