]> mj.ucw.cz Git - libucw.git/blob - ucw/opt.h
Opt: OPT_MULTIPLE implemented, no tests yet but seems working
[libucw.git] / ucw / opt.h
1 /*
2  *      UCW Library -- Parsing of command line options
3  *
4  *      (c) 2013 Jan Moskyto Matejka <mq@ucw.cz>
5  *
6  *      This software may be freely distributed and used according to the terms
7  *      of the GNU Lesser General Public License.
8  */
9
10 #ifndef _UCW_OPT_H
11 #define _UCW_OPT_H
12
13 #include <ucw/lib.h>
14 #include <ucw/conf.h>
15
16 #include <stdlib.h>
17 #include <stdio.h>
18
19 #define OPT_EXIT_BAD_ARGS 2
20
21 /***
22  * [[opt]]
23  ***/
24
25 enum opt_class {
26   OPT_CL_END,     // end of list
27   OPT_CL_BOOL,    // boolean value
28   OPT_CL_STATIC,  // static value
29   OPT_CL_SWITCH,  // lookup/switch
30   OPT_CL_INC,     // incremental value
31   OPT_CL_CALL,    // call a function
32   OPT_CL_USER,    // user defined value
33   OPT_CL_SECTION, // subsection
34   OPT_CL_HELP,    // help line
35 };
36
37 struct opt_section;
38 struct opt_item {
39   const char * name;                    // long-op
40   int letter;                           // short-op
41   void * ptr;                           // where to save
42   const char * help;                    // description in --help
43   union opt_union {
44     struct opt_section * section;       // subsection for OPT_SECTION
45     int value;                          // value for OPT_SWITCH
46     void (* call)(struct opt_item * opt, const char * value, void * data);  // function to call for OPT_CALL
47     struct cf_user_type * utype;        // specification of the user-defined type
48   } u;
49   u16 flags;
50   byte cls;                             // enum opt_class
51   byte type;                            // enum cf_type
52 };
53
54 struct opt_section {
55   struct opt_item * opt;
56 };
57
58 #define OPT_ITEMS       .opt = ( struct opt_item[] )  /** List of sub-items. **/
59
60 /***
61  * Sub-items to be enclosed in OPT_ITEMS { } list
62  * ----------------------------------------------
63  *
64  *  OPT_HELP_OPTION declares --help and prints a line about that
65  *  OPT_HELP prints a line into help
66  *  OPT_HELP2 prints two strings onto a line using the same tab structure as the option listing
67  *  OPT_BOOL declares boolean option with an auto-negation (--sth and --no-sth). It's also possible to write --sth=y/yes/true/1/n/no/false/0.
68  *  OPT_STRING, OPT_UNS, OPT_INT declare simple string/uns/int option
69  *  OPT_SWITCH declares one choice of a switch statement; these have common target and different `value`s; last wins unless OPT_SINGLE is set;
70  *             parser fails if it matches an OPT_SWITCH with OPT_SINGLE set and also target set.
71  *             Target must be of signed integer type; it is set to -1 if no switch appears at the command-line.
72  *  OPT_CALL calls the given function with an argument, giving also the opt_item structure and some custom data.
73  *  OPT_USER declares a custom type of value defined by the given @cf_user_type in @ttype
74  *  OPT_INC declares an incremental value like -v/--verbose
75  *  OPT_SECTION declares a subsection
76  *
77  ***/
78
79 #define OPT_HELP_OPTION OPT_CALL(0, "help", opt_show_help_internal, NULL, OPT_NO_VALUE, "Show this help")
80 #define OPT_HELP(line) { .help = line, .cls = OPT_CL_HELP }
81 #define OPT_BOOL(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .help = desc, .flags = fl, .cls = OPT_CL_BOOL, .type = CT_INT }
82 #define OPT_STRING(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .help = desc, .flags = fl, .cls = OPT_CL_STATIC, .type = CT_STRING }
83 #define OPT_U64(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .help = desc, .flags = fl, .cls = OPT_CL_STATIC, .type = CT_U64 }
84 #define OPT_INT(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .help = desc, .flags = fl, .cls = OPT_CL_STATIC, .type = CT_INT }
85 #define OPT_DOUBLE(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .help = desc, .flags = fl, .cls = OPT_CL_STATIC, .type = CT_DOUBLE }
86 #define OPT_IP(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .help = desc, .flags = fl, .cls = OPT_CL_STATIC, .type = CT_IP }
87 #define OPT_SWITCH(shortopt, longopt, target, val, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .help = desc, .flags = fl, .cls = OPT_CL_SWITCH, .type = CT_LOOKUP, .u.value = val }
88 #define OPT_CALL(shortopt, longopt, fn, data, fl, desc) { .letter = shortopt, .name = longopt, .ptr = data, .help = desc, .u.call = fn, .flags = fl, .cls = OPT_CL_CALL, .type = CT_USER }
89 #define OPT_USER(shortopt, longopt, target, ttype, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .u.utype = &ttype, .flags = fl, .help = desc, .cls = OPT_CL_USER, .type = CT_USER }
90 #define OPT_INC(shortopt, longopt, target, fl, desc) { .letter = shortopt, .name = longopt, .ptr = &target, .flags = fl, .help = desc, .cls = OPT_CL_INC, .type = CT_INT }
91 #define OPT_SECTION(sec) { .cls = OPT_CL_SECTION, .u.section = &sec }
92 #define OPT_END { .cls = OPT_CL_END }
93
94 /***
95  * Predefined shortopt arguments
96  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
97  *
98  * for the preceeding calls if positional args wanted.
99  * Arguments are processed in the order of the numbers given to them. There must be first
100  * the args with OPT_REQUIRED (see lower) and after them the args without OPT_REQUIRED, no mixing.
101  * You may define a catch-all option as OPT_POSITIONAL_TAIL. After this, no positional arg is allowed.
102  * You may shuffle the positional arguments in any way in the opt sections but the numbering must obey
103  * the rules given here.
104  ***/
105
106 #define OPT_POSITIONAL(n)   (OPT_POSITIONAL_TAIL+(n))     
107 #define OPT_POSITIONAL_TAIL 256
108
109
110 /***
111  * Flags for the preceeding calls
112  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
113  ***/
114
115 #define OPT_REQUIRED        0x1         /** Argument must appear at the command line **/
116 #define OPT_REQUIRED_VALUE  0x2         /** Argument must have a value **/
117 #define OPT_NO_VALUE        0x4         /** Argument must have no value **/
118 #define OPT_MAYBE_VALUE     0x8         /** Argument may have a value **/
119 #define OPT_VALUE_FLAGS     (OPT_REQUIRED_VALUE | OPT_NO_VALUE | OPT_MAYBE_VALUE)
120 #define OPT_NEGATIVE        0x10        /** Reversing the effect of OPT_INC or saving @false into OPT_BOOL **/
121 #define OPT_NO_HELP         0x20        /** Omit this line from help **/
122 #define OPT_LAST_ARG        0x40        /** Stop processing argv after this line **/
123 #define OPT_SINGLE          0x100       /** Argument must appear at most once **/
124 #define OPT_MULTIPLE        0x200       /** Argument may appear any time; will save all the values into a simple list **/
125
126
127 /***
128  * Value flags defaults
129  * ~~~~~~~~~~~~~~~~~~~~
130  *
131  * OPT_NO_VALUE for OPT_BOOL, OPT_SWITCH and OPT_INC
132  * OPT_MAYBE_VALUE for OPT_STRING, OPT_UNS, OPT_INT
133  * Some of the value flags (OPT_NO_VALUE, OPT_MAYBE_VALUE, OPT_REQUIRED_VALUE)
134  * must be specified for OPT_CALL and OPT_USER.
135  ***/
136
137 static uns opt_default_value_flags[] = {
138   [OPT_CL_BOOL] = OPT_NO_VALUE,
139   [OPT_CL_STATIC] = OPT_MAYBE_VALUE,
140   [OPT_CL_SWITCH] = OPT_NO_VALUE,
141   [OPT_CL_INC] = OPT_NO_VALUE,
142   [OPT_CL_CALL] = 0,
143   [OPT_CL_USER] = 0,
144   [OPT_CL_SECTION] = 0,
145   [OPT_CL_HELP] = 0
146 };
147
148 extern const struct opt_section * opt_section_root;
149 void opt_help_internal(const struct opt_section * help);
150
151 static void opt_help(void) {
152   opt_help_internal(opt_section_root);
153 }
154
155 static void opt_usage(void) {
156   fprintf(stderr, "Run with argument --help for more information.\n");
157 }
158
159 static void opt_show_help_internal(struct opt_item * opt UNUSED, const char * value UNUSED, void * data UNUSED) {
160   opt_help();
161   exit(0);
162 }
163
164 /**
165  * Parse all the arguments. Run the @callback for each of the positional argument.
166  **/
167 void opt_parse(const struct opt_section * options, char ** argv);
168
169 #endif