/builddir/build/BUILD/libutil++-1.4.0/src/sella/util/CommandLine.cpp

/*
** libutil++
** $Id: CommandLine.cpp 1230 2014-11-16 02:32:01Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: CommandLine.cpp 1230 2014-11-16 02:32:01Z sella $";

#include "CommandLine.h"
#include "CommandLineOption.h"

#include <unistd.h>
#include <getopt.h>
#include <stdio.h>

#include <exception>
#include <string>
#include <vector>
#include <list>
#include <map>

using namespace sella::util;

CommandLine::CommandLine(int argc, char **argv) throw () :
   argc(argc),
   argv(argv),

   option(),
   argument(),

   width(0)
{ }

CommandLine::CommandLine(const CommandLine &copy) throw () :
   argc(copy.argc),
   argv(copy.argv),

   option(copy.option),
   argument(copy.argument),

   width(copy.width)
{ }

CommandLine::~CommandLine() throw () {
   this->option.clear();
   this->argument.clear();
}

CommandLine &sella::util::CommandLine::operator=(const CommandLine &other) throw () {
   if (this != &other) {
      this->argc = other.argc;
      this->argv = other.argv;

      this->option = other.option;
      this->argument = other.argument;

      this->width = other.width;
   }

   return *this;
}

void CommandLine::add(char opt, const std::string &option, const std::string &usage, const std::string &label, const std::string &value) throw () {
        this->add(CommandLineOption(opt, option, usage, label, value));
}

void CommandLine::add(char opt, const std::string &option, const std::string &usage, const std::string &label, long value, long min, long max) throw () {
        char buf[31];
        std::string v;

        if (min != MINLONG &&value < min) {
                value = min;
        } else if (max != MINLONG &&value > max) {
                value = max;
        }

        snprintf(buf, sizeof(buf), "%lu", value);
        v = buf;

   this->add(CommandLineOption(opt, option, usage, label, v));
}

void CommandLine::add(const CommandLineOption &option) throw () {
   if (this->width < option.getTags().size()) {
      this->width = option.getTags().size();
   }

   this->option.push_back(option);
}

void CommandLine::add(const std::string &argument, const std::string &usage) throw () {
   if (this->width < (argument.size() + 4)) {
      this->width = argument.size() + 4;
   }

   this->argument.push_back(std::pair<std::string, std::string>(argument, usage));
}

void CommandLine::usage(FILE *stream, int result) const throw () {
   std::string left;
   left.resize(this->width, ' ');

   /* Print the usage summary header. */
   if (this->option.size() > 0) {
      fprintf(stream, "\nUSAGE: %s [OPTIONS]", this->argv[0]);
   } else {
      fprintf(stream, "\nUSAGE: %s", this->argv[0]);
   }

   for (auto iter = this->argument.cbegin(); iter != this->argument.cend(); iter++) {
      fprintf(stream, " %s", iter->first.c_str());
   }

   /* Print the argument usage detail. */
   if (this->argument.size() > 0) {
      fprintf(stream, "\n  ARGUMENTS\n");
   }

   for (auto iter = this->argument.cbegin(); iter != this->argument.cend(); iter++) {
      std::string argument(iter->first);
      argument.insert(0, 4, ' ');
      argument.resize(this->width, ' ');

      fprintf(stream, "%s   %s\n", argument.c_str(), iter->second.c_str());
   }

   /* Print the option usage detail. */
   if (this->option.size() > 0) {
      fprintf(stream, "\n  OPTIONS\n");
   }

   for (auto iter = this->option.cbegin(); iter != this->option.cend(); iter++) {
      std::string tags(iter->getTags());

      if (tags.size() > 0) {
         tags.resize(this->width, ' ');

#if 0
         fprintf(stream, "%s   %s\n", tags.c_str(), iter->getUsage().c_str());

         if (iter->getValue().size() > 0) {
            fprintf(stream, "%s   [DEFAULT: %s]\n", left.c_str(), iter->getValue().c_str());
         }
#else
         if (iter->getValue().size() > 0) {
                                fprintf(stream, "%s   %s (default: %s)\n", tags.c_str(), iter->getUsage().c_str(), iter->getValue().c_str());
                        } else {
                                fprintf(stream, "%s   %s\n", tags.c_str(), iter->getUsage().c_str());
                        }
#endif
      } else {
         fprintf(stream, "\n");
      }
   }

   fprintf(stream, "\n");

   /* Terminate execution. */
   _exit(result);
}

std::map<std::string, std::string> CommandLine::parse(FILE *stream) const throw () {
   std::map<std::string, std::string>  result;
   std::map<char, std::string>         lookup;

   std::vector<struct option>          long_option;
   std::string                         option;

   int                                 index;
   int                                 c;

   /* Build the parsing structures. */
   for (auto iter = this->option.cbegin(); iter != this->option.cend(); iter++) {
      if (iter->getTags().size() > 0) {
         long_option.push_back(this->build(iter->getOpt(), iter->getOption(), iter->getArgumented()));
         option.append(this->tag(iter->getOpt(), iter->getArgumented()));

         if (iter->getValue().size() > 0) {
            result[iter->getOption()] = iter->getValue();
         }

         lookup[iter->getOpt()] = iter->getOption();
      }
   }

   long_option.push_back(this->build(0, std::string(), 0));

   /* Parse the command line options. */
   while ((c = getopt_long(this->argc, this->argv, option.c_str(), &(long_option[0]), &index)) >= 0) {
      if (lookup.find(c) != lookup.end()) {
         if (optarg != 0) {
            result[lookup[c]] = std::string(optarg);
         } else {
            result[lookup[c]] = std::string();
         }
      } else {
         this->usage(stream, -1);
      }
   }

   /* Parse the command line aguments. */
   if (argc != (optind + (int)(this->argument.size()))) {
      this->usage(stream, -2);
   } else {
      for (auto iter = this->argument.cbegin(); iter != this->argument.cend(); iter++) {
         result[iter->first] = argv[optind++];
      }
   }

   return std::map<std::string, std::string>(result);
}

struct option CommandLine::build(char tag, const std::string &name, bool argument) const throw () {
   struct option  option = { (name.size() > 0) ? name.c_str() : NULL, (argument == true) ? 1 : 0, NULL, tag };

   return option;
}

const std::string CommandLine::tag(char tag, bool argument) const throw () {
   char  buffer[4];

   if (((tag >= 'a') &&(tag <= 'z')) || ((tag >= 'A') &&(tag <= 'Z')) || ((tag >= '0') &&(tag <= '9'))) {
      if (argument) {
         snprintf(buffer, 4, "%c:", tag);
      } else {
         snprintf(buffer, 4, "%c", tag);
      }
   } else {
      buffer[0] = 0;
   }

   return std::string(buffer);
}

/*
** vim: noet ts=3 sw=3
*/

---