MFC:
[dragonfly.git] / contrib / com_err / getarg.c
blob6972e6987c41d7ff2a7644523d9c48c460ecf4e6
1 /*
2 * Copyright (c) 1997, 1998 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed by Kungliga Tekniska
20 * Högskolan and its contributors.
22 * 4. Neither the name of the Institute nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
26 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
39 #if 0
40 RCSID("$Id: getarg.c,v 1.25 1998/11/22 09:45:05 assar Exp $");
41 #endif
43 #include <sys/ttycom.h>
44 #include <time.h>
45 #include <stdio.h>
46 #include "getarg.h"
48 #define ISFLAG(X) ((X).type == arg_flag || (X).type == arg_negative_flag)
50 static size_t
51 print_arg (char *string, size_t len, int mdoc, int longp, struct getargs *arg)
53 const char *s;
55 *string = '\0';
57 if (ISFLAG(*arg))
58 return 0;
60 if(mdoc){
61 if(longp)
62 strncat(string, "= Ns", len);
63 strncat(string, " Ar ", len);
64 }else
65 if (longp)
66 strncat (string, "=", len);
67 else
68 strncat (string, " ", len);
70 if (arg->arg_help)
71 s = arg->arg_help;
72 else if (arg->type == arg_integer)
73 s = "number";
74 else if (arg->type == arg_string)
75 s = "string";
76 else
77 s = "<undefined>";
79 strncat(string, s, len);
80 return 1 + strlen(s);
83 static int
84 check_column(FILE *f, int col, int len, int columns)
86 if(col + len > columns) {
87 fprintf(f, "\n");
88 col = fprintf(f, " ");
90 return col;
93 void
94 arg_printusage (struct getargs *args,
95 size_t num_args,
96 const char *progname,
97 const char *extra_string)
99 int i;
100 size_t max_len = 0;
101 char buf[128];
102 int col = 0, columns;
103 struct winsize ws;
105 columns = 80;
106 col = 0;
107 col += fprintf (stderr, "Usage: %s", progname);
108 for (i = 0; i < num_args; ++i) {
109 size_t len = 0;
111 if (args[i].long_name) {
112 buf[0] = '\0';
113 strncat(buf, "[--", sizeof(buf));
114 len += 2;
115 if(args[i].type == arg_negative_flag) {
116 strncat(buf, "no-", sizeof(buf));
117 len += 3;
119 strncat(buf, args[i].long_name, sizeof(buf));
120 len += strlen(args[i].long_name);
121 len += print_arg(buf + strlen(buf), sizeof(buf) - strlen(buf),
122 0, 1, &args[i]);
123 strncat(buf, "]", sizeof(buf));
124 if(args[i].type == arg_strings)
125 strncat(buf, "...", sizeof(buf));
126 col = check_column(stderr, col, strlen(buf) + 1, columns);
127 col += fprintf(stderr, " %s", buf);
129 if (args[i].short_name) {
130 snprintf(buf, sizeof(buf), "[-%c", args[i].short_name);
131 len += 2;
132 len += print_arg(buf + strlen(buf), sizeof(buf) - strlen(buf),
133 0, 0, &args[i]);
134 strncat(buf, "]", sizeof(buf));
135 if(args[i].type == arg_strings)
136 strncat(buf, "...", sizeof(buf));
137 col = check_column(stderr, col, strlen(buf) + 1, columns);
138 col += fprintf(stderr, " %s", buf);
140 if (args[i].long_name && args[i].short_name)
141 len += 2; /* ", " */
142 max_len = max(max_len, len);
144 if (extra_string) {
145 col = check_column(stderr, col, strlen(extra_string) + 1, columns);
146 fprintf (stderr, " %s\n", extra_string);
147 } else
148 fprintf (stderr, "\n");
149 for (i = 0; i < num_args; ++i) {
150 if (args[i].help) {
151 size_t count = 0;
153 if (args[i].short_name) {
154 count += fprintf (stderr, "-%c", args[i].short_name);
155 print_arg (buf, sizeof(buf), 0, 0, &args[i]);
156 count += fprintf(stderr, "%s", buf);
158 if (args[i].short_name && args[i].long_name)
159 count += fprintf (stderr, ", ");
160 if (args[i].long_name) {
161 count += fprintf (stderr, "--");
162 if (args[i].type == arg_negative_flag)
163 count += fprintf (stderr, "no-");
164 count += fprintf (stderr, "%s", args[i].long_name);
165 print_arg (buf, sizeof(buf), 0, 1, &args[i]);
166 count += fprintf(stderr, "%s", buf);
168 while(count++ <= max_len)
169 putc (' ', stderr);
170 fprintf (stderr, "%s\n", args[i].help);
175 static void
176 add_string(getarg_strings *s, char *value)
178 s->strings = realloc(s->strings, (s->num_strings + 1) * sizeof(*s->strings));
179 s->strings[s->num_strings] = value;
180 s->num_strings++;
183 static int
184 arg_match_long(struct getargs *args, size_t num_args,
185 char *argv)
187 int i;
188 char *optarg = NULL;
189 int negate = 0;
190 int partial_match = 0;
191 struct getargs *partial = NULL;
192 struct getargs *current = NULL;
193 int argv_len;
194 char *p;
196 argv_len = strlen(argv);
197 p = strchr (argv, '=');
198 if (p != NULL)
199 argv_len = p - argv;
201 for (i = 0; i < num_args; ++i) {
202 if(args[i].long_name) {
203 int len = strlen(args[i].long_name);
204 char *p = argv;
205 int p_len = argv_len;
206 negate = 0;
208 for (;;) {
209 if (strncmp (args[i].long_name, p, p_len) == 0) {
210 if(p_len == len)
211 current = &args[i];
212 else {
213 ++partial_match;
214 partial = &args[i];
216 optarg = p + p_len;
217 } else if (ISFLAG(args[i]) && strncmp (p, "no-", 3) == 0) {
218 negate = !negate;
219 p += 3;
220 p_len -= 3;
221 continue;
223 break;
225 if (current)
226 break;
229 if (current == NULL) {
230 if (partial_match == 1)
231 current = partial;
232 else
233 return ARG_ERR_NO_MATCH;
236 if(*optarg == '\0' && !ISFLAG(*current))
237 return ARG_ERR_NO_MATCH;
238 switch(current->type){
239 case arg_integer:
241 int tmp;
242 if(sscanf(optarg + 1, "%d", &tmp) != 1)
243 return ARG_ERR_BAD_ARG;
244 *(int*)current->value = tmp;
245 return 0;
247 case arg_string:
249 *(char**)current->value = optarg + 1;
250 return 0;
252 case arg_strings:
254 add_string((getarg_strings*)current->value, optarg + 1);
255 return 0;
257 case arg_flag:
258 case arg_negative_flag:
260 int *flag = current->value;
261 if(*optarg == '\0' ||
262 strcmp(optarg + 1, "yes") == 0 ||
263 strcmp(optarg + 1, "true") == 0){
264 *flag = !negate;
265 return 0;
266 } else if (*optarg && strcmp(optarg + 1, "maybe") == 0) {
267 *flag = rand() & 1;
268 } else {
269 *flag = negate;
270 return 0;
272 return ARG_ERR_BAD_ARG;
274 default:
275 abort ();
280 getarg(struct getargs *args, size_t num_args,
281 int argc, char **argv, int *optind)
283 int i, j, k;
284 int ret = 0;
286 srand (time(NULL));
287 (*optind)++;
288 for(i = *optind; i < argc; i++) {
289 if(argv[i][0] != '-')
290 break;
291 if(argv[i][1] == '-'){
292 if(argv[i][2] == 0){
293 i++;
294 break;
296 ret = arg_match_long (args, num_args, argv[i] + 2);
297 if(ret)
298 return ret;
299 }else{
300 for(j = 1; argv[i][j]; j++) {
301 for(k = 0; k < num_args; k++) {
302 char *optarg;
303 if(args[k].short_name == 0)
304 continue;
305 if(argv[i][j] == args[k].short_name){
306 if(args[k].type == arg_flag){
307 *(int*)args[k].value = 1;
308 break;
310 if(args[k].type == arg_negative_flag){
311 *(int*)args[k].value = 0;
312 break;
314 if(argv[i][j + 1])
315 optarg = &argv[i][j + 1];
316 else{
317 i++;
318 optarg = argv[i];
320 if(optarg == NULL)
321 return ARG_ERR_NO_ARG;
322 if(args[k].type == arg_integer){
323 int tmp;
324 if(sscanf(optarg, "%d", &tmp) != 1)
325 return ARG_ERR_BAD_ARG;
326 *(int*)args[k].value = tmp;
327 goto out;
328 }else if(args[k].type == arg_string){
329 *(char**)args[k].value = optarg;
330 goto out;
331 }else if(args[k].type == arg_strings){
332 add_string((getarg_strings*)args[k].value, optarg);
333 goto out;
335 return ARG_ERR_BAD_ARG;
339 if (k == num_args)
340 return ARG_ERR_NO_MATCH;
342 out:;
345 *optind = i;
346 return 0;
349 #if TEST
350 int foo_flag = 2;
351 int flag1 = 0;
352 int flag2 = 0;
353 int bar_int;
354 char *baz_string;
356 struct getargs args[] = {
357 { NULL, '1', arg_flag, &flag1, "one", NULL },
358 { NULL, '2', arg_flag, &flag2, "two", NULL },
359 { "foo", 'f', arg_negative_flag, &foo_flag, "foo", NULL },
360 { "bar", 'b', arg_integer, &bar_int, "bar", "seconds"},
361 { "baz", 'x', arg_string, &baz_string, "baz", "name" },
364 int main(int argc, char **argv)
366 int optind = 0;
367 while(getarg(args, 5, argc, argv, &optind))
368 printf("Bad arg: %s\n", argv[optind]);
369 printf("flag1 = %d\n", flag1);
370 printf("flag2 = %d\n", flag2);
371 printf("foo_flag = %d\n", foo_flag);
372 printf("bar_int = %d\n", bar_int);
373 printf("baz_flag = %s\n", baz_string);
374 arg_printusage (args, 5, argv[0], "nothing here");
376 #endif