tdb2: copy tdb1's changed expansion logic.
[ccan] / ccan / opt / usage.c
1 /* Licensed under GPLv3+ - see LICENSE file for details */
2 #include <ccan/opt/opt.h>
3 #include <sys/ioctl.h>
4 #include <string.h>
5 #include <stdlib.h>
6 #include <stdio.h>
7 #include <stdint.h>
8 #include "private.h"
9
10 /* We only use this for pointer comparisons. */
11 const char opt_hidden[1];
12
13 #define MIN_DESC_WIDTH 40
14 #define MIN_TOTAL_WIDTH 50
15
16 static unsigned int get_columns(void)
17 {
18         struct winsize w;
19         const char *env = getenv("COLUMNS");
20
21         w.ws_col = 0;
22         if (env)
23                 w.ws_col = atoi(env);
24         if (!w.ws_col)
25                 if (ioctl(0, TIOCGWINSZ, &w) == -1)
26                         w.ws_col = 0;
27         if (!w.ws_col)
28                 w.ws_col = 80;
29
30         return w.ws_col;
31 }
32
33 /* Return number of chars of words to put on this line.
34  * Prefix is set to number to skip at start, maxlen is max width, returns
35  * length (after prefix) to put on this line. */
36 static size_t consume_words(const char *words, size_t maxlen, size_t *prefix)
37 {
38         size_t oldlen, len;
39
40         /* Swallow leading whitespace. */
41         *prefix = strspn(words, " ");
42         words += *prefix;
43
44         /* Use at least one word, even if it takes us over maxlen. */
45         oldlen = len = strcspn(words, " ");
46         while (len <= maxlen) {
47                 oldlen = len;
48                 len += strspn(words+len, " ");
49                 len += strcspn(words+len, " ");
50                 if (len == oldlen)
51                         break;
52         }
53
54         return oldlen;
55 }
56
57 static char *add_str_len(char *base, size_t *len, size_t *max,
58                          const char *str, size_t slen)
59 {
60         if (slen >= *max - *len)
61                 base = realloc(base, *max = (*max * 2 + slen + 1));
62         memcpy(base + *len, str, slen);
63         *len += slen;
64         return base;
65 }
66
67 static char *add_str(char *base, size_t *len, size_t *max, const char *str)
68 {
69         return add_str_len(base, len, max, str, strlen(str));
70 }
71
72 static char *add_indent(char *base, size_t *len, size_t *max, size_t indent)
73 {
74         if (indent >= *max - *len)
75                 base = realloc(base, *max = (*max * 2 + indent + 1));
76         memset(base + *len, ' ', indent);
77         *len += indent;
78         return base;
79 }
80
81 static char *add_desc(char *base, size_t *len, size_t *max,
82                       unsigned int indent, unsigned int width,
83                       const struct opt_table *opt)
84 {
85         size_t off, prefix, l;
86         const char *p;
87         bool same_line = false;
88
89         base = add_str(base, len, max, opt->names);
90         off = strlen(opt->names);
91         if (opt->type == OPT_HASARG
92             && !strchr(opt->names, ' ')
93             && !strchr(opt->names, '=')) {
94                 base = add_str(base, len, max, " <arg>");
95                 off += strlen(" <arg>");
96         }
97
98         /* Do we start description on next line? */
99         if (off + 2 > indent) {
100                 base = add_str(base, len, max, "\n");
101                 off = 0;
102         } else {
103                 base = add_indent(base, len, max, indent - off);
104                 off = indent;
105                 same_line = true;
106         }
107
108         /* Indent description. */
109         p = opt->desc;
110         while ((l = consume_words(p, width - indent, &prefix)) != 0) {
111                 if (!same_line)
112                         base = add_indent(base, len, max, indent);
113                 p += prefix;
114                 base = add_str_len(base, len, max, p, l);
115                 base = add_str(base, len, max, "\n");
116                 off = indent + l;
117                 p += l;
118                 same_line = false;
119         }
120
121         /* Empty description?  Make it match normal case. */
122         if (same_line)
123                 base = add_str(base, len, max, "\n");
124
125         if (opt->show) {
126                 char buf[OPT_SHOW_LEN + sizeof("...")];
127                 strcpy(buf + OPT_SHOW_LEN, "...");
128                 opt->show(buf, opt->u.arg);
129
130                 /* If it doesn't fit on this line, indent. */
131                 if (off + strlen(" (default: ") + strlen(buf) + strlen(")")
132                     > width) {
133                         base = add_indent(base, len, max, indent);
134                 } else {
135                         /* Remove \n. */
136                         (*len)--;
137                 }
138
139                 base = add_str(base, len, max, " (default: ");
140                 base = add_str(base, len, max, buf);
141                 base = add_str(base, len, max, ")\n");
142         }
143         return base;
144 }
145
146 char *opt_usage(const char *argv0, const char *extra)
147 {
148         unsigned int i;
149         size_t max, len, width, indent;
150         char *ret;
151
152         width = get_columns();
153         if (width < MIN_TOTAL_WIDTH)
154                 width = MIN_TOTAL_WIDTH;
155
156         /* Figure out longest option. */
157         indent = 0;
158         for (i = 0; i < opt_count; i++) {
159                 size_t l;
160                 if (opt_table[i].desc == opt_hidden)
161                         continue;
162                 if (opt_table[i].type == OPT_SUBTABLE)
163                         continue;
164                 l = strlen(opt_table[i].names);
165                 if (opt_table[i].type == OPT_HASARG
166                     && !strchr(opt_table[i].names, ' ')
167                     && !strchr(opt_table[i].names, '='))
168                         l += strlen(" <arg>");
169                 if (l + 2 > indent)
170                         indent = l + 2;
171         }
172
173         /* Now we know how much to indent */
174         if (indent + MIN_DESC_WIDTH > width)
175                 indent = width - MIN_DESC_WIDTH;
176
177         len = max = 0;
178         ret = NULL;
179
180         ret = add_str(ret, &len, &max, "Usage: ");
181         ret = add_str(ret, &len, &max, argv0);
182
183         /* Find usage message from among registered options if necessary. */
184         if (!extra) {
185                 extra = "";
186                 for (i = 0; i < opt_count; i++) {
187                         if (opt_table[i].cb == (void *)opt_usage_and_exit
188                             && opt_table[i].u.carg) {
189                                 extra = opt_table[i].u.carg;
190                                 break;
191                         }
192                 }
193         }
194         ret = add_str(ret, &len, &max, " ");
195         ret = add_str(ret, &len, &max, extra);
196         ret = add_str(ret, &len, &max, "\n");
197
198         for (i = 0; i < opt_count; i++) {
199                 if (opt_table[i].desc == opt_hidden)
200                         continue;
201                 if (opt_table[i].type == OPT_SUBTABLE) {
202                         ret = add_str(ret, &len, &max, opt_table[i].desc);
203                         ret = add_str(ret, &len, &max, ":\n");
204                         continue;
205                 }
206                 ret = add_desc(ret, &len, &max, indent, width, &opt_table[i]);
207         }
208         ret[len] = '\0';
209         return ret;
210 }