├── test_argv.cpp
├── README.md
└── argv.h


/test_argv.cpp:
--------------------------------------------------------------------------------
 1 | #include "argv.h"
 2 | 
 3 | int main(int argc, const char *argv[]) {
 4 |     PARM(int, n, "Number of elements", "1");
 5 |     PARM(double, k, "Constant", "3.14");
 6 |     PARM(std::string, name, "Name of element", "");
 7 | 
 8 |     parse_argv("testparms", argc, argv);
 9 | 
10 |     printf("n = %i\n"
11 |            "k = %.18g\n"
12 |            "name = '%s'\n",
13 |            n, k, name.c_str());
14 | 
15 |     return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # argv
 2 | A simple argc/argv parser
 3 | 
 4 | Example usage:
 5 | 
 6 |     #include <stdio.h>
 7 |     #include <string>
 8 |     #include "argv.h"
 9 | 
10 |     int main(int argc, const char *argv[]) {
11 |         PARM(int, n, "Number of elements", "1");
12 |         PARM(double, k, "Constant", "3.14");
13 |         PARM(std::string, name, "Name of element", "");
14 | 
15 |         parse_argv("testparms", argc, argv);
16 | 
17 |         printf("n = %i\n"
18 |                "k = %.18g\n"
19 |                "name = '%s'\n",
20 |                n, k, name.c_str());
21 | 
22 |         return 0;
23 |     }
24 | 


--------------------------------------------------------------------------------
/argv.h:
--------------------------------------------------------------------------------
 1 | #if !defined(ARGV_H_INCLUDED)
 2 | #define ARGV_H_INCLUDED
 3 | 
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 6 | #include <map>
 7 | #include <string>
 8 | #include <vector>
 9 | 
10 | struct Parm {
11 |     static std::map<std::string, Parm *>& parms() {
12 |         static std::map<std::string, Parm *> p;
13 |         return p;
14 |     }
15 | 
16 |     std::string name;
17 |     std::string description;
18 |     std::string value;
19 | 
20 |     Parm(const std::string& name, const std::string description, const std::string& value)
21 |         : name(name), description(description), value(value)
22 |     {
23 |         parms()[name] = this;
24 |     }
25 | 
26 |     virtual void parse(const char *v) = 0;
27 | };
28 | 
29 | template<typename T>
30 | void parse(T& x, const char *s);
31 | 
32 | template<typename T>
33 | struct TParm : Parm {
34 |     T* x;
35 |     TParm(T *x, const std::string& name, const std::string& description, const std::string& value)
36 |         : Parm{name, description, value}, x{x}
37 |     {
38 |         ::parse(*x, value.c_str());
39 |     }
40 |     virtual void parse(const char *v) { ::parse(*x, v); }
41 | };
42 | 
43 | template<> void parse(int& x, const char *s) { x = atoi(s); }
44 | template<> void parse(float& x, const char *s) { x = atof(s); }
45 | template<> void parse(double& x, const char *s) { x = atof(s); }
46 | template<> void parse(std::string& x, const char *s) { x = s; }
47 | 
48 | inline void parse_argv(const char *program, int argc, const char *argv[]) {
49 |     auto help = [&](){
50 |         fprintf(stderr, "%s - Valid parameters are:\n", program);
51 |         for (auto& i : Parm::parms()) {
52 |             fprintf(stderr, "  --%s : %s%s\n",
53 |                     i.first.c_str(),
54 |                     i.second->description.c_str(),
55 |                     i.second->value.size() == 0 ? "" : ("[default " + i.second->value + "]").c_str());
56 |         }
57 |         exit(1);
58 |     };
59 |     for (int i=1; i<argc; i++) {
60 |         if (i<argc-1 && argv[i][0] == '-' && argv[i][1] == '-') {
61 |             auto it = Parm::parms().find(argv[i]+2);
62 |             if (it == Parm::parms().end()) {
63 |                 fprintf(stderr, "Unknown parameter '%s'\n", argv[i]);
64 |                 help();
65 |             }
66 |             it->second->parse(argv[++i]);
67 |         } else {
68 |             fprintf(stderr, "Invalid syntax '%s'\n", argv[i]);
69 |             help();
70 |         }
71 |     }
72 | }
73 | 
74 | #define PARM(type, n, descr, value)              \
75 |     type n; new TParm<type>(&n, #n, descr, value)
76 | 
77 | #endif
78 | 


--------------------------------------------------------------------------------