options.cxx

Go to the documentation of this file.

//
// Copyright 2002, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.


#include <cxxtls/options.h>
#include <stdlib.h>
#include <portable_io.h>
#include <algorithm>
#include <ctype.h>
#include <string.h>

using namespace std;

namespace cxxtls
{


ProgramOptions*
ProgramOptions::
global_options_=0;  // global variable holding _the_ program options.  If null
                    // then no options are processed

void
ProgramOptions::
constructor(const ProgramOptions::Descriptors& desc,
            int                                argc,
            const char*const*                  args,
            const char*const*                  environ,
            bool                               exit_on_error
           )
  //
  // This is the real constructor that parses the parms, environment, etc.
  //
{
   // create the environment first because its easy

   if(environ)
   {
     while(*environ)
     {
       char const *p = *environ++;

       char const *equal = (char const*)(memchr(p, '=', strlen(p)));

       if(!equal)
         continue;  // badly formed environment????

       string name(p, equal);

       string value(equal+1, equal+strlen(equal));

       setenv(name, value);

     }
   }

   if(argc && args)
   {
      argv.push_back(*args);  // save argument 0 in the argv array and don't
                              // process it like it was an option
                        
      --argc;
      ++args;

      while(argc)
      {
        // parse the options into the options map and the arguments into argv
        
        if(args[0][0] == '-')
        {
          // handle -options
        
           std::vector<Descriptor>::const_iterator f = desc.options_.begin();
           std::vector<Descriptor>::const_iterator l = desc.options_.end();
        
           // look for an exact match of the current argument value
           // within the option descriptors
        
           while( f != l)
           {
              if( f->name_ == *args )
              {
                break;
              }
        
              ++f;
        
           }
        
           bool single_char_parm=false;
        
           if(f == l)
           {
             // didn't find it, try some other strategies:
             //
             //  1:  see if there is a single character option which
             //      has the same value as the first character of the
             //      parm.  If it does and if it accepts parameters
             //      then treat the rest of the parm as its parameter.
             //
        
             string tmp(args[0], args[0]+2);
        
             for(f = desc.options_.begin(); f != l; ++f)
               if(tmp == f->name_ && f->parms_)
                 {
                   single_char_parm=true;
                   break;
                 }
           }
        
           if(f == l)
           {
        
             // did not find a match of any form
        
             char buffer[2048];
        
             sprintf(buffer, "program option '%s' is not recognized", *args);
        
             if(exit_on_error_)
             {
               fprintf(stderr, "%s\n", buffer);
               exit(1);
             }
        
             error_ = true;
        
             errmsg_ = buffer;
        
             return;
        
           }
        
           // at this point, we know that f points to a valid descriptor for this
           // argument
        
           if(single_char_parm && strlen(*args) > 2)
           {
             // this is a single character parm whose data is in the same
             // string:  -Ifilename
             //
        
             string name(*args, *args + 2);

             Option *opt = get_option(name); // see if option already set

             if(opt)
             {
               opt->append_value(string(*args+2, *args + strlen(*args)));
             }
             else
             {
               Option &newbie = add_option(name);
        
               newbie.append_value(string(*args+2, *args + strlen(*args)));
             }

           }
           else
           {
        
             Option *newbie = get_option(*args);  // see if already set
        
             if(!newbie)
               newbie = &add_option(*args);    // nope, add it
             else
             {
               // option was already set -- so this is a second
               // invocation.  If the option doesn't take parameters
               // then this means to unset the option
        
               if(f->parms_ == no_values)
               {
                 // unset it
                
                 remove_option(*args);
                
                 --argc;
                 ++args;
                
                 continue;  // the outer loop to parse options
                
               }
               else
               if(f->parms_ == one_value)
               {
                 // whoa, this is an error, you can't
                 // set more than one value for this guy.
                
                 char buffer[2048];

                 sprintf(buffer, "Multiple settings of option '%s' not allowed", *args);
                
                 if(exit_on_error_)
                 {
                   fprintf(stderr, "%s\n", buffer);
                   exit(1);
                 }
                
                 error_ = true;
                
                 errmsg_ = buffer;
                
                 return;
               }
        
             }
        
             if(f->parms_ && argc)
             {
               --argc; // skip to the data part
               ++args;
        
               newbie->append_value(*args);
             }
           }
        }
        else
        {
          argv.push_back(*args);
        }
        
        --argc;
        ++args;
      }
   }
}

ProgramOptions::Option&
ProgramOptions::
add_option(string const &name)
{
  Option* p = new Option(name);

  options_.insert( std::pair<string, Option*>(name, p) );

  return *p;
}


void
ProgramOptions::
Descriptors::
add_option(string const &name, int parms)
{
  options_.push_back(Descriptor(name, parms));
}

void
ProgramOptions::
setenv(string const &name, string const &value)
{
   environ_.insert( std::pair<string,string> (name, value) );
}

ProgramOptions::EnvVar
ProgramOptions::
getenv(string const &name) const
{
  std::map<string,string>::const_iterator e;

  e = environ_.find(name);

  if(e == environ_.end())
    return EnvVar(name);

  return EnvVar(name, e->second);

}

ProgramOptions::
~ProgramOptions()
{
  // free up any memory not automatically cleaned up
  // by containers.

  while(options_.begin() != options_.end())
  {
    Options::iterator i = options_.begin();

    Option* tmp = i->second;

    options_.erase(i);  // remove 'i' from the container

    delete tmp;

  }

}

void
ProgramOptions::Option::
append_value(string const &value)
{
  values_.push_back(value);

}


ProgramOptions::Option::
Option(string const &name)
: name_(name),
  set_(true)
{
}


ProgramOptions::Option::
Option()
: name_("not set"),
  set_(false)
{
}

string
ProgramOptions::Option::
value() const
{
   string rv;

   if(values_.size() != 0)
   {
      vector<string>::const_iterator f = values_.begin();
      vector<string>::const_iterator l = values_.end();

      static string comma(",");

      do
      {
        rv += *f;
        
        ++f;
        
        if(f != l)
        {
          rv += comma;
        }
        
      }
      while(f != l);


   }

   return rv;
}

ProgramOptions::Option*
ProgramOptions::
get_option(string const &name)
{
  Options::const_iterator f = options_.find(name);

  if(f == options_.end())
    return 0;

  return f->second;
}

void
ProgramOptions::
remove_option(string const &name)
{
  Options::iterator f = options_.find(name);

  if(f != options_.end())
    options_.erase(f);
}

ProgramOptions::Option
ProgramOptions::
null_option_;


ProgramOptions::Option const&
ProgramOptions::
option(string const &name) const
{
  ProgramOptions* me = (ProgramOptions*)(this);

  Option* rv = me->get_option(name);

  if(!rv)
    return null_option_;

  return *rv;

}


ProgramOptions::
ProgramOptions(string             text_desc,
               int                argc,
               const char*const*  args,
               const char*const*  environ,
               bool               exit_on_error
              )
: exit_on_error_(exit_on_error),
  error_(false)
{
  // construct the options given a string instead of a vector of
  // descriptors for the options.  The vector of options is created
  // from the string.

  string::iterator nc = text_desc.begin();
  string::iterator lc = text_desc.end();

  ProgramOptions::Descriptors desc;

  string option_name;

  while(nc != lc)
  {
     char c = *nc++;

     int values=-1;

     if(c == ',')
       values=no_values;
     else
     if(c == ':')
       values=one_value;
     else
     if(c == ';')
       values=many_values;
     else
       option_name += c;

     if(values >= 0)
     {
       // end of current option;

       if(option_name.size())
         desc.add_option(option_name, values);
        
       option_name.resize(0);

     }

  }

  if(option_name.size() && option_name[0] == '-')
  {
    // must have forgotten the trailing separator -- assume ','

    desc.add_option(option_name, no_values);

  }

  constructor(desc, argc, args, environ, exit_on_error);

}

string
ProgramOptions::
expand(string const &in) const
{
  string rv;

  size_t offset=0;

  size_t in_size = in.size();

  while(offset < in_size)
  {
     string::const_iterator start  = in.begin() + offset;
     string::const_iterator end    = in.end();
     string::const_iterator dollar = find(start, end, '$');

     if(dollar == end)
     {
       // whoops, out of text

       rv.append(start, end);
       return rv;

     }
     else
     {
       // perform a substitituion

       rv.append(start, dollar);

       ++dollar;

       if(dollar == end)  // last char in string was dollar, thats baaaaad
         return rv;
        
       char c = *dollar;

       if(c >= '0' && c < '9')
       {
         // parm substitution
        
         ++dollar;
        
         c -= '0';
        
         // c is now a parm index
        
         if( size_t(c) < argv.size())
         {
           rv += argv[c];
         }
        
       }
       else
       {
         // environment variable substitution
        
         string varname;
        
         while(dollar < end &&
               ( isalnum(*dollar) || *dollar == '_')
              )
         {

             varname += *dollar++;

         }
        
         string value = getenv(varname);
        
         rv += value;
        
         char const *varname_ptr = varname.c_str();
         char const *value_ptr   = value.c_str();
        
         if(value_ptr == varname_ptr)
           varname_ptr = value_ptr;
        
       }

       offset = dollar - in.begin();

     }
  }

  return rv;

}

} // namespace cxxtls