Mercurial > libpst

comparison XGetopt.c @ 0:6b1b602514db libpst_0_5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial revision
author carl
date Fri, 09 Jul 2004 07:26:16 -0700
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:6b1b602514db
1 // XGetopt.cpp Version 1.1
2 //
3 // Author: Hans Dietrich
4 // hdietrich2@hotmail.com
5 //
6 // Modified: David Smith
7 // dave.s@earthcorp.com
8 // Moved two char declarations from body of function so
9 // that it can compile as a C function.
10 // Thanks so much Hans
11 //
12 // This software is released into the public domain.
13 // You are free to use it in any way you like.
14 //
15 // This software is provided "as is" with no expressed
16 // or implied warranty. I accept no liability for any
17 // damage or loss of business that this software may cause.
18 //
19 ///////////////////////////////////////////////////////////////////////////////
20
21 #include <stdio.h>
22 #include <string.h>
23 #include "XGetopt.h"
24
25 ///////////////////////////////////////////////////////////////////////////////
26 //
27 // X G e t o p t . c p p
28 //
29 //
30 // NAME
31 // getopt -- parse command line options
32 //
33 // SYNOPSIS
34 // int getopt(int argc, char *argv[], char *optstring)
35 //
36 // extern char *optarg;
37 // extern int optind;
38 //
39 // DESCRIPTION
40 // The getopt() function parses the command line arguments. Its
41 // arguments argc and argv are the argument count and array as
42 // passed into the application on program invocation. In the case
43 // of Visual C++ programs, argc and argv are available via the
44 // variables __argc and __argv (double underscores), respectively.
45 // getopt returns the next option letter in argv that matches a
46 // letter in optstring.
47 //
48 // optstring is a string of recognized option letters; if a letter
49 // is followed by a colon, the option is expected to have an argument
50 // that may or may not be separated from it by white space. optarg
51 // is set to point to the start of the option argument on return from
52 // getopt.
53 //
54 // Option letters may be combined, e.g., "-ab" is equivalent to
55 // "-a -b". Option letters are case sensitive.
56 //
57 // getopt places in the external variable optind the argv index
58 // of the next argument to be processed. optind is initialized
59 // to 0 before the first call to getopt.
60 //
61 // When all options have been processed (i.e., up to the first
62 // non-option argument), getopt returns EOF, optarg will point
63 // to the argument, and optind will be set to the argv index of
64 // the argument. If there are no non-option arguments, optarg
65 // will be set to NULL.
66 //
67 // The special option "--" may be used to delimit the end of the
68 // options; EOF will be returned, and "--" (and everything after it)
69 // will be skipped.
70 //
71 // RETURN VALUE
72 // For option letters contained in the string optstring, getopt
73 // will return the option letter. getopt returns a question mark (?)
74 // when it encounters an option letter not included in optstring.
75 // EOF is returned when processing is finished.
76 //
77 // BUGS
78 // 1) Long options are not supported.
79 // 2) The GNU double-colon extension is not supported.
80 // 3) The environment variable POSIXLY_CORRECT is not supported.
81 // 4) The + syntax is not supported.
82 // 5) The automatic permutation of arguments is not supported.
83 // 6) This implementation of getopt() returns EOF if an error is
84 // encountered, instead of -1 as the latest standard requires.
85 //
86 // EXAMPLE
87 // BOOL CMyApp::ProcessCommandLine(int argc, char *argv[])
88 // {
89 // int c;
90 //
91 // while ((c = getopt(argc, argv, "aBn:")) != EOF)
92 // {
93 // switch (c)
94 // {
95 // case 'a':
96 // TRACE(_T("option a\n"));
97 // //
98 // // set some flag here
99 // //
100 // break;
101 //
102 // case 'B':
103 // TRACE( _T("option B\n"));
104 // //
105 // // set some other flag here
106 // //
107 // break;
108 //
109 // case 'n':
110 // TRACE(_T("option n: value=%d\n"), atoi(optarg));
111 // //
112 // // do something with value here
113 // //
114 // break;
115 //
116 // case '?':
117 // TRACE(_T("ERROR: illegal option %s\n"), argv[optind-1]);
118 // return FALSE;
119 // break;
120 //
121 // default:
122 // TRACE(_T("WARNING: no handler for option %c\n"), c);
123 // return FALSE;
124 // break;
125 // }
126 // }
127 // //
128 // // check for non-option args here
129 // //
130 // return TRUE;
131 // }
132 //
133 ///////////////////////////////////////////////////////////////////////////////
134
135 char *optarg; // global argument pointer
136 int optind = 0; // global argv index
137
138 int getopt(int argc, char *argv[], char *optstring)
139 {
140 static char *next = NULL;
141 char c, *cp;
142 if (optind == 0)
143 next = NULL;
144
145 optarg = NULL;
146
147 if (next == NULL || *next == '\0')
148 {
149 if (optind == 0)
150 optind++;
151
152 if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0')
153 {
154 optarg = NULL;
155 if (optind < argc)
156 optarg = argv[optind];
157 return EOF;
158 }
159
160 if (strcmp(argv[optind], "--") == 0)
161 {
162 optind++;
163 optarg = NULL;
164 if (optind < argc)
165 optarg = argv[optind];
166 return EOF;
167 }
168
169 next = argv[optind]+1;
170 optind++;
171 }
172
173 c = *next++;
174 cp = strchr(optstring, c);
175
176 if (cp == NULL || c == ':')
177 return '?';
178
179 cp++;
180 if (*cp == ':')
181 {
182 if (*next != '\0')
183 {
184 optarg = next;
185 next = NULL;
186 }
187 else if (optind < argc)
188 {
189 optarg = argv[optind];
190 optind++;
191 }
192 else
193 {
194 return '?';
195 }
196 }
197
198 return c;
199 }