---

CTBargv.cxx

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*------------------------------------------+---------------------------------*/

#include <string.h>
#include <ctype.h>

#include "CTB.hxx"
#include "CTB_Trace.hxx"
#include "CTBargv.hxx"

//------------------------------------------+-----------------------------------

CTBargv::CTBargv()
  : mi_argc(0),
    mc_args(0),
    m_argv(0),
    mi_curarg(-1)
{
  CTB_Trace("CTBargv()");
}

//------------------------------------------+-----------------------------------

CTBargv::CTBargv(int argc, char* argv[])
  : mi_argc(argc),
    mc_args(0),
    m_argv(0),
    mi_curarg(-1)
{
  CTB_Trace("CTBargv(int,char*[])");
  int   i_totlen = 0;
  char* c_cur;

  if (argc <= 0) return;

  m_argv  = new argdsc[argc];

  for (int i = 0; i < argc; i++) {
    int i_nchar = strlen(argv[i]);
    m_argv[i].mi_nchar = i_nchar;
    i_totlen += 1 + i_nchar;
  }

  mc_args = new char[i_totlen];

  c_cur = mc_args;
  for (int i = 0; i < argc; i++) {
    m_argv[i].mc_arg = c_cur;
    strcpy(c_cur,argv[i]);
    c_cur += 1 + m_argv[i].mi_nchar;
  }  
  
  m_argv[0].mb_used = true;                 // mark argv[0] used
}

//------------------------------------------+-----------------------------------

CTBargv::~CTBargv()
{
  CTB_Trace("~CTBargv()");

  delete mc_args;
  delete [] m_argv;
}

//------------------------------------------+-----------------------------------

bool CTBargv::Locate(const char* c_opt, int i_npar)
{
  CTB_Trace("CTBargv::Locate(const char*,int)");

  mi_curarg = -1;

  for (int i = 1; i < mi_argc; i++) {
    if (!m_argv[i].mb_used && strcmp(c_opt,m_argv[i].mc_arg) == 0) {
      m_argv[i].mb_used = true;
      mi_curarg         = i;
      break;
    }
  }
  
  if (mi_curarg >= 0) {
    int  i_lastarg    = mi_curarg + i_npar;
    bool b_error_npar = false;

    if (i_lastarg >= mi_argc) {
      b_error_npar = true;
      i_lastarg    = mi_argc - 1;
    }

    for (int i = mi_curarg+1; i <= i_lastarg; i++) {
      if (m_argv[i].mb_used) b_error_npar = true;
    }

    if (b_error_npar) {
      for (int i = mi_curarg; i <= i_lastarg; i++) {
        m_argv[i].mb_used       = true;
        m_argv[i].mi_errorflags = mi_error_npar;
      }
      mi_curarg = -1;
    }
  }
  
  
  return mi_curarg >= 0;
}

//------------------------------------------+-----------------------------------

const char* CTBargv::NextArg()
{
  CTB_Trace("CTBargv::NextArg()");

  if (mi_curarg < 0 || mi_curarg >= mi_argc-1) {
    mi_curarg = -1;
    return 0;
  }

  mi_curarg                += 1;
  m_argv[mi_curarg].mb_used = true;
  return  m_argv[mi_curarg].mc_arg;
}

//------------------------------------------+-----------------------------------

void CTBargv::CheckUnused()
{
  CTB_Trace("CTBargv::CheckUnused()");

  for (int i = 0; i < mi_argc; i++) {
    if (!m_argv[i].mb_used) {
      m_argv[i].mb_used       = true;
      m_argv[i].mi_errorflags = mi_error_unused;
    }
  }
  return;
}


//------------------------------------------+-----------------------------------

bool CTBargv::CheckErrors()
{
  CTB_Trace("CTBargv::CheckErrors()");

  for (int i = 0; i < mi_argc; i++) {
    if (m_argv[i].mi_errorflags != 0) return true;
  }
  return false;
}

//------------------------------------------+-----------------------------------

bool CTBargv::CheckErrors(ostream& os)
{
  CTB_Trace("CTBargv::CheckErrors(ostream&)");

  if (!CheckErrors()) return false;         // if all fine
  for (int i = 0; i < mi_argc; i++) {
    int i_errorflags = m_argv[i].mi_errorflags;
    if ((i_errorflags & mi_error_unused) != 0) {
      os << "%CTBargv-E unused argument \"" << 
        m_argv[i].mc_arg << "\"" << endl;
    }
    if ((i_errorflags & mi_error_conv) != 0) {
      os << "%CTBargv-E conversion error in \"" << 
        m_argv[i].mc_arg << "\"" << endl;
    }
    if ((i_errorflags & mi_error_npar) != 0) {
      os << "%CTBargv-E insufficient option arguments for \"" << 
        m_argv[i].mc_arg << "\"" << endl;
    }
  }
  return true;
}

//------------------------------------------+-----------------------------------

void CTBargv::SetupStream(istrstream& istr)
{
  CTB_Trace("CTBargv::SetupStrea(istrstream&)");

  istr.clear();                             // ??? noop
  return;
}

//------------------------------------------+-----------------------------------

void CTBargv::CheckStream(istrstream& istr)
{
  CTB_Trace("CTBargv::CheckStream(istrstream&)");

  bool b_nonwhite  = false;
  int  i_ncharleft = 0;
  char c;
  
  istr.clear();                             // set good bit again
  
  while(istr.get(c)) {                      // read rest of string stream
    i_ncharleft += 1;                       // count them
    if (!isspace(c)) b_nonwhite = true;     // and check for non white space
  }
  
  if (b_nonwhite && mi_curarg >= 0) {
    m_argv[mi_curarg].mi_errorflags = mi_error_conv;
    m_argv[mi_curarg].mi_ncharleft  = i_ncharleft;
  }

  return;
}

//------------------------------------------+-----------------------------------

void CTBargv::ToStream(ostream& os) const
{
  CTB_Trace("CTBargv::ToStream(ostream&)");

  os << "Number of arguments: " << mi_argc << endl;
  for (int i = 0; i < mi_argc; i++){
    os << setw(3) << i << ": ";
    os << ((!m_argv[i].mb_used) ? "u" : " ");
    os << ((m_argv[i].mi_errorflags) ? "e" : " ");
    os << " \"";
    os << m_argv[i].mc_arg;
    os << "\"";
    if (m_argv[i].mi_errorflags) {
      int i_ncharleft = m_argv[i].mi_ncharleft;
      int i_nchar     = m_argv[i].mi_nchar;
      if (i_ncharleft > 0 && i_ncharleft <= i_nchar) {
        os << endl;
        os << "         ";
        for (int iz = 0; iz < i_nchar-i_ncharleft; iz++) os << " ";
        os << "^";
      }
    }
    
    os << endl;
  }
  return;
}

//------------------------------------------+-----------------------------------
CTBargv::argdsc::argdsc()                   // constructor
  : mc_arg(0),
    mi_nchar(0),
    mi_ncharleft(0),
    mb_used(false),
    mi_errorflags(0)
{}

//------------------------------------------+-----------------------------------

#if (defined(CTB__OutLine) || defined(CTBargv__OutLine))
#define inline
#include "CTBargv.icc"
#undef  inline
#endif

---