~ubuntu-branches/ubuntu/raring/ifile/raring

« back to all changes in this revision

Viewing changes to argp/argp-test.c

  • Committer: Bazaar Package Importer
  • Author(s): Jens Peter Secher
  • Date: 2004-11-19 23:30:24 UTC
  • Revision ID: james.westby@ubuntu.com-20041119233024-3s7sqpy963jx22eu
Tags: upstream-1.3.4
ImportĀ upstreamĀ versionĀ 1.3.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
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 Library General Public License as
 
8
   published by the Free Software Foundation; either version 2 of the
 
9
   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
   Library General Public License for more details.
 
15
 
 
16
   You should have received a copy of the GNU Library General Public
 
17
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
 
18
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
19
   Boston, MA 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
 
 
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
 
 
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
 
 
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
}