checks/getopt.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85


#include "getopt.h"

#include <botan/parsing.h>
#include <botan/exceptn.h>

OptionParser::OptionParser(const std::string& opt_string)
   {
   std::vector<std::string> opts = Botan::split_on(opt_string, '|');

   for(size_t j = 0; j != opts.size(); j++)
      flags.push_back(OptionFlag(opts[j]));
   }

OptionParser::OptionFlag
OptionParser::find_option(const std::string& name) const
   {
   for(size_t j = 0; j != flags.size(); j++)
      if(flags[j].name() == name)
         return flags[j];
   throw Botan::Exception("Unknown option " + name);
   }

bool OptionParser::is_set(const std::string& key) const
   {
   return (options.find(key) != options.end());
   }

std::string OptionParser::value(const std::string& key) const
   {
   std::map<std::string, std::string>::const_iterator i = options.find(key);
   if(i == options.end())
      throw Botan::Exception("Option " + key + " not found");
   return i->second;
   }

std::string OptionParser::value_if_set(const std::string& key) const
   {
   return is_set(key) ? value(key) : "";
   }

void OptionParser::parse(char* argv[])
   {
   std::vector<std::string> args;
   for(int j = 1; argv[j]; j++)
      args.push_back(argv[j]);

   for(size_t j = 0; j != args.size(); j++)
      {
      std::string arg = args[j];

      if(arg.size() > 2 && arg[0] == '-' && arg[1] == '-')
         {
         const std::string opt_name = arg.substr(0, arg.find('='));

         arg = arg.substr(2);

         std::string::size_type mark = arg.find('=');

         OptionFlag opt = find_option(arg.substr(0, mark));

         if(opt.takes_arg())
            {
            if(mark == std::string::npos)
               throw Botan::Exception("Option " + opt_name +
                                      " requires an argument");

            std::string name = arg.substr(0, mark);
            std::string value = arg.substr(mark+1);

            options[name] = value;
            }
         else
            {
            if(mark != std::string::npos)
               throw Botan::Exception("Option " + opt_name +
                                      " does not take an argument");

            options[arg] = "";
            }
         }
      else
         leftover.push_back(arg);
      }
   }