/normxcorr/trunk

To get this branch, use:
bzr branch http://suren.me/webbzr/normxcorr/trunk

« back to all changes in this revision

Viewing changes to dict_hw/src/win/getopt_long.c

  • Committer: Suren A. Chilingaryan
  • Date: 2010-04-17 07:43:38 UTC
  • Revision ID: csa@dside.dyndns.org-20100417074338-l45lxndn5tv72bpx
Patches for windows port

Show diffs side-by-side

added added

removed removed

Lines of Context:
dict_hw/src/win/getopt_long.c
 
1
/*
 
2
 * Copyright (c) 1987, 1993, 1994, 1996
 
3
 *      The Regents of the University of California.  All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 * 1. Redistributions of source code must retain the above copyright
 
9
 *    notice, this list of conditions and the following disclaimer.
 
10
 * 2. Redistributions in binary form must reproduce the above copyright
 
11
 *    notice, this list of conditions and the following disclaimer in the
 
12
 *    documentation and/or other materials provided with the distribution.
 
13
 * 3. All advertising materials mentioning features or use of this software
 
14
 *    must display the following acknowledgement:
 
15
 *      This product includes software developed by the University of
 
16
 *      California, Berkeley and its contributors.
 
17
 * 4. Neither the name of the University nor the names of its contributors
 
18
 *    may be used to endorse or promote products derived from this software
 
19
 *    without specific prior written permission.
 
20
 *
 
21
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 
22
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
23
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
24
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 
25
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
26
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 
27
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
28
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 
29
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 
30
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 
31
 * SUCH DAMAGE.
 
32
 */
 
33
#include <assert.h>
 
34
#include <errno.h>
 
35
#include <stdio.h>
 
36
#include <stdlib.h>
 
37
#include <string.h>
 
38
#include "getopt.h"
 
39
 
 
40
#define __P(x) x
 
41
#define _DIAGASSERT(x) assert(x)
 
42
 
 
43
static char * __progname __P((char *));
 
44
int getopt_internal __P((int, char * const *, const char *));
 
45
 
 
46
static char *
 
47
__progname(nargv0)
 
48
        char * nargv0;
 
49
{
 
50
        char * tmp;
 
51
 
 
52
        _DIAGASSERT(nargv0 != NULL);
 
53
 
 
54
        tmp = strrchr(nargv0, '/');
 
55
        if (tmp)
 
56
                tmp++;
 
57
        else
 
58
                tmp = nargv0;
 
59
        return(tmp);
 
60
}
 
61
 
 
62
#define BADCH   (int)'?'
 
63
#define BADARG  (int)':'
 
64
#define EMSG    ""
 
65
 
 
66
/*
 
67
 * getopt --
 
68
 *      Parse argc/argv argument vector.
 
69
 */
 
70
int
 
71
getopt_internal(nargc, nargv, ostr)
 
72
        int nargc;
 
73
        char * const *nargv;
 
74
        const char *ostr;
 
75
{
 
76
        static char *place = EMSG;              /* option letter processing */
 
77
        char *oli;                              /* option letter list index */
 
78
 
 
79
        _DIAGASSERT(nargv != NULL);
 
80
        _DIAGASSERT(ostr != NULL);
 
81
 
 
82
        if (optreset || !*place) {              /* update scanning pointer */
 
83
                optreset = 0;
 
84
                if (optind >= nargc || *(place = nargv[optind]) != '-') {
 
85
                        place = EMSG;
 
86
                        return (-1);
 
87
                }
 
88
                if (place[1] && *++place == '-') {      /* found "--" */
 
89
                        /* ++optind; */
 
90
                        place = EMSG;
 
91
                        return (-2);
 
92
                }
 
93
        }                                       /* option letter okay? */
 
94
        if ((optopt = (int)*place++) == (int)':' ||
 
95
            !(oli = strchr(ostr, optopt))) {
 
96
                /*
 
97
                 * if the user didn't specify '-' as an option,
 
98
                 * assume it means -1.
 
99
                 */
 
100
                if (optopt == (int)'-')
 
101
                        return (-1);
 
102
                if (!*place)
 
103
                        ++optind;
 
104
                if (opterr && *ostr != ':')
 
105
                        (void)fprintf(stderr,
 
106
                            "%s: illegal option -- %c\n", __progname(nargv[0]), optopt);
 
107
                return (BADCH);
 
108
        }
 
109
        if (*++oli != ':') {                    /* don't need argument */
 
110
                optarg = NULL;
 
111
                if (!*place)
 
112
                        ++optind;
 
113
        } else {                                /* need an argument */
 
114
                if (*place)                     /* no white space */
 
115
                        optarg = place;
 
116
                else if (nargc <= ++optind) {   /* no arg */
 
117
                        place = EMSG;
 
118
                        if ((opterr) && (*ostr != ':'))
 
119
                                (void)fprintf(stderr,
 
120
                                    "%s: option requires an argument -- %c\n",
 
121
                                    __progname(nargv[0]), optopt);
 
122
                        return (BADARG);
 
123
                } else                          /* white space */
 
124
                        optarg = nargv[optind];
 
125
                place = EMSG;
 
126
                ++optind;
 
127
        }
 
128
        return (optopt);                        /* dump back option letter */
 
129
}
 
130
 
 
131
#if 0
 
132
/*
 
133
 * getopt --
 
134
 *      Parse argc/argv argument vector.
 
135
 */
 
136
int
 
137
getopt2(nargc, nargv, ostr)
 
138
        int nargc;
 
139
        char * const *nargv;
 
140
        const char *ostr;
 
141
{
 
142
        int retval;
 
143
 
 
144
        if ((retval = getopt_internal(nargc, nargv, ostr)) == -2) {
 
145
                retval = -1;
 
146
                ++optind; 
 
147
        }
 
148
        return(retval);
 
149
}
 
150
#endif
 
151
 
 
152
/*
 
153
 * getopt_long --
 
154
 *      Parse argc/argv argument vector.
 
155
 */
 
156
int
 
157
getopt_long(nargc, nargv, options, long_options, index)
 
158
        int nargc;
 
159
        char ** nargv;
 
160
        char * options;
 
161
        struct option * long_options;
 
162
        int * index;
 
163
{
 
164
        int retval;
 
165
 
 
166
        _DIAGASSERT(nargv != NULL);
 
167
        _DIAGASSERT(options != NULL);
 
168
        _DIAGASSERT(long_options != NULL);
 
169
        /* index may be NULL */
 
170
 
 
171
        if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
 
172
                char *current_argv = nargv[optind++] + 2, *has_equal;
 
173
                size_t current_argv_len;
 
174
                int i, match = -1;
 
175
 
 
176
                if (*current_argv == '\0') {
 
177
                        return(-1);
 
178
                }
 
179
                if ((has_equal = strchr(current_argv, '=')) != NULL) {
 
180
                        current_argv_len = has_equal - current_argv;
 
181
                        has_equal++;
 
182
                } else
 
183
                        current_argv_len = strlen(current_argv);
 
184
 
 
185
                for (i = 0; long_options[i].name; i++) { 
 
186
                        if (strncmp(current_argv, long_options[i].name, current_argv_len))
 
187
                                continue;
 
188
 
 
189
                        if (strlen(long_options[i].name) == (unsigned)current_argv_len) { 
 
190
                                match = i;
 
191
                                break;
 
192
                        }
 
193
                        if (match == -1)
 
194
                                match = i;
 
195
                }
 
196
                if (match != -1) {
 
197
                        if (long_options[match].has_arg == required_argument ||
 
198
                            long_options[match].has_arg == optional_argument) {
 
199
                                if (has_equal)
 
200
                                        optarg = has_equal;
 
201
                                else
 
202
                                        optarg = nargv[optind++];
 
203
                        }
 
204
                        if ((long_options[match].has_arg == required_argument)
 
205
                            && (optarg == NULL)) {
 
206
                                /*
 
207
                                 * Missing argument, leading :
 
208
                                 * indicates no error should be generated
 
209
                                 */
 
210
                                if ((opterr) && (*options != ':'))
 
211
                                        (void)fprintf(stderr,
 
212
                                      "%s: option requires an argument -- %s\n",
 
213
                                      __progname(nargv[0]), current_argv);
 
214
                                return (BADARG);
 
215
                        }
 
216
                } else { /* No matching argument */
 
217
                        if ((opterr) && (*options != ':'))
 
218
                                (void)fprintf(stderr,
 
219
                                    "%s: illegal option -- %s\n", __progname(nargv[0]), current_argv);
 
220
                        return (BADCH);
 
221
                }
 
222
                if (long_options[match].flag) {
 
223
                        *long_options[match].flag = long_options[match].val;
 
224
                        retval = 0;
 
225
                } else 
 
226
                        retval = long_options[match].val;
 
227
                if (index)
 
228
                        *index = match;
 
229
        }
 
230
        return(retval);
 
231
}