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