.
[kopensolaris-gnu/glibc.git] / argp / argp-test.c
1 /* Test program for argp argument parser
2    Copyright (C) 1997 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Written by Miles Bader <miles@gnu.ai.mit.edu>.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include <stdlib.h>
26 #include <time.h>
27 #include <string.h>
28 #include <argp.h>
29
30 const char *argp_program_version = "argp-test 1.0";
31 \f
32 struct argp_option sub_options[] =
33 {
34   {"subopt1",       's',     0,  0, "Nested option 1"},
35   {"subopt2",       'S',     0,  0, "Nested option 2"},
36
37   { 0, 0, 0, 0, "Some more nested options:", 10},
38   {"subopt3",       'p',     0,  0, "Nested option 3"},
39
40   {"subopt4",       'q',     0,  0, "Nested option 4", 1},
41
42   {0}
43 };
44
45 static const char sub_args_doc[] = "STRING...\n-";
46 static const char sub_doc[] = "\vThis is the doc string from the sub-arg-parser.";
47
48 static error_t
49 sub_parse_opt (int key, char *arg, struct argp_state *state)
50 {
51   switch (key)
52     {
53     case ARGP_KEY_NO_ARGS:
54       printf ("NO SUB ARGS\n");
55       break;
56     case ARGP_KEY_ARG:
57       printf ("SUB ARG: %s\n", arg);
58       break;
59
60     case 's' : case 'S': case 'p': case 'q':
61       printf ("SUB KEY %c\n", key);
62       break;
63
64     default:
65       return ARGP_ERR_UNKNOWN;
66     }
67   return 0;
68 }
69
70 static char *
71 sub_help_filter (int key, const char *text, void *input)
72 {
73   if (key == ARGP_KEY_HELP_EXTRA)
74     return strdup ("This is some extra text from the sub parser (note that it \
75 is preceded by a blank line).");
76   else
77     return (char *)text;
78 }
79
80 static struct argp sub_argp = {
81   sub_options, sub_parse_opt, sub_args_doc, sub_doc, 0, sub_help_filter
82 };
83 \f
84 /* Structure used to communicate with the parsing functions.  */
85 struct params
86 {
87   unsigned foonly;              /* Value parsed for foonly.  */
88   unsigned foonly_default;      /* Default value for it.  */
89 };
90
91 #define OPT_PGRP 1
92 #define OPT_SESS 2
93
94 struct argp_option options[] =
95 {
96   {"pid",       'p',     "PID", 0, "List the process PID"},
97   {"pgrp",      OPT_PGRP,"PGRP",0, "List processes in the process group PGRP"},
98   {"no-parent", 'P',     0,     0, "Include processes without parents"},
99   {0,           'x',     0,     OPTION_ALIAS},
100   {"all-fields",'Q',     0,     0, "Don't elide unusable fields (normally"
101                                    " if there's some reason ps can't"
102                                    " print a field for any process, it's"
103                                    " removed from the output entirely)" },
104   {"reverse",   'r',    0,      0, "Reverse the order of any sort"},
105   {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
106   {"session",  OPT_SESS,"SID",  OPTION_ARG_OPTIONAL,
107                                    "Add the processes from the session"
108                                    " SID (which defaults to the sid of"
109                                    " the current process)" },
110
111   {0,0,0,0, "Here are some more options:"},
112   {"foonly", 'f', "ZOT", OPTION_ARG_OPTIONAL, "Glork a foonly"},
113   {"zaza", 'z', 0, 0, "Snit a zar"},
114
115   {0}
116 };
117
118 static const char args_doc[] = "STRING";
119 static const char doc[] = "Test program for argp."
120  "\vThis doc string comes after the options."
121  "\nHey!  Some manual formatting!"
122  "\nThe current time is: %s";
123
124 static void
125 popt (int key, char *arg)
126 {
127   char buf[10];
128   if (isprint (key))
129     sprintf (buf, "%c", key);
130   else
131     sprintf (buf, "%d", key);
132   if (arg)
133     printf ("KEY %s: %s\n", buf, arg);
134   else
135     printf ("KEY %s\n", buf);
136 }
137
138 static error_t
139 parse_opt (int key, char *arg, struct argp_state *state)
140 {
141   struct params *params = state->input;
142
143   switch (key)
144     {
145     case ARGP_KEY_NO_ARGS:
146       printf ("NO ARGS\n");
147       break;
148
149     case ARGP_KEY_ARG:
150       if (state->arg_num > 0)
151         return ARGP_ERR_UNKNOWN; /* Leave it for the sub-arg parser.  */
152       printf ("ARG: %s\n", arg);
153       break;
154
155     case 'f':
156       if (arg)
157         params->foonly = atoi (arg);
158       else
159         params->foonly = params->foonly_default;
160       popt (key, arg);
161       break;
162
163     case 'p': case 'P': case OPT_PGRP: case 'x': case 'Q':
164     case 'r': case OPT_SESS: case 'z':
165       popt (key, arg);
166       break;
167
168     default:
169       return ARGP_ERR_UNKNOWN;
170     }
171   return 0;
172 }
173
174 static char *
175 help_filter (int key, const char *text, void *input)
176 {
177   char *new_text;
178   struct params *params = input;
179
180   if (key == ARGP_KEY_HELP_POST_DOC && text)
181     {
182       time_t now = time (0);
183       asprintf (&new_text, text, ctime (&now));
184     }
185   else if (key == 'f')
186     /* Show the default for the --foonly option.  */
187     asprintf (&new_text, "%s (ZOT defaults to %x)",
188               text, params->foonly_default);
189   else
190     new_text = (char *)text;
191
192   return new_text;
193 }
194
195 static struct argp_child argp_children[] = { { &sub_argp }, { 0 } };
196 static struct argp argp = {
197   options, parse_opt, args_doc, doc, argp_children, help_filter
198 };
199 \f
200 int
201 main (int argc, char **argv)
202 {
203   struct params params;
204   params.foonly = 0;
205   params.foonly_default = random ();
206   argp_parse (&argp, argc, argv, 0, 0, &params);
207   printf ("After parsing: foonly = %x\n", params.foonly);
208   return 0;
209 }