getopt.cpp@ 62559

Last change on this file since 62559 was 62477, checked in by vboxsync, 8 years ago
(C) 2016
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 27.8 KB

Line
1	/* $Id: getopt.cpp 62477 2016-07-22 18:27:37Z vboxsync $ */
2	/** @file
3	* IPRT - Command Line Parsing
4	*/
5
6	/*
7	* Copyright (C) 2007-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#include <iprt/cidr.h>
32	#include <iprt/net.h> /* must come before getopt.h */
33	#include <iprt/getopt.h>
34	#include "internal/iprt.h"
35
36	#include <iprt/assert.h>
37	#include <iprt/ctype.h>
38	#include <iprt/err.h>
39	#include <iprt/message.h>
40	#include <iprt/string.h>
41	#include <iprt/uuid.h>
42
43
44	/*********************************************************************************************************************************
45	* Global Variables *
46	*********************************************************************************************************************************/
47	/**
48	* Standard options that gets included unless RTGETOPTINIT_FLAGS_NO_STD_OPTS is
49	* set.
50	*/
51	static RTGETOPTDEF const g_aStdOptions[] =
52	{
53	{ "--help", 'h', RTGETOPT_REQ_NOTHING },
54	{ "-help", 'h', RTGETOPT_REQ_NOTHING },
55	{ "--version", 'V', RTGETOPT_REQ_NOTHING },
56	{ "-version", 'V', RTGETOPT_REQ_NOTHING },
57	};
58	/** The index of --help in g_aStdOptions. Used for some trickery. */
59	#define RTGETOPT_STD_OPTIONS_HELP_IDX 0
60
61
62
63	RTDECL(int) RTGetOptInit(PRTGETOPTSTATE pState, int argc, char **argv,
64	PCRTGETOPTDEF paOptions, size_t cOptions,
65	int iFirst, uint32_t fFlags)
66	{
67	AssertReturn(!(fFlags & ~(RTGETOPTINIT_FLAGS_OPTS_FIRST \| RTGETOPTINIT_FLAGS_NO_STD_OPTS)), VERR_INVALID_PARAMETER);
68
69	pState->argv = argv;
70	pState->argc = argc;
71	pState->paOptions = paOptions;
72	pState->cOptions = cOptions;
73	pState->iNext = iFirst;
74	pState->pszNextShort = NULL;
75	pState->pDef = NULL;
76	pState->uIndex = UINT32_MAX;
77	pState->fFlags = fFlags;
78	pState->cNonOptions = 0;
79
80	/* validate the options. */
81	for (size_t i = 0; i < cOptions; i++)
82	{
83	Assert(!(paOptions[i].fFlags & ~RTGETOPT_VALID_MASK));
84	Assert(paOptions[i].iShort > 0);
85	Assert(paOptions[i].iShort != VINF_GETOPT_NOT_OPTION);
86	Assert(paOptions[i].iShort != '-');
87	}
88
89	return VINF_SUCCESS;
90	}
91	RT_EXPORT_SYMBOL(RTGetOptInit);
92
93
94	/**
95	* Converts an stringified IPv4 address into the RTNETADDRIPV4 representation.
96	*
97	* @returns VINF_SUCCESS on success, VERR_GETOPT_INVALID_ARGUMENT_FORMAT on
98	* failure.
99	*
100	* @param pszValue The value to convert.
101	* @param pAddr Where to store the result.
102	*/
103	static int rtgetoptConvertIPv4Addr(const char *pszValue, PRTNETADDRIPV4 pAddr)
104	{
105	if (RT_FAILURE(RTNetStrToIPv4Addr(pszValue, pAddr)))
106	return VERR_GETOPT_INVALID_ARGUMENT_FORMAT;
107	return VINF_SUCCESS;
108	}
109
110
111	/**
112	* Converts an stringified Ethernet MAC address into the RTMAC representation.
113	*
114	* @returns VINF_SUCCESS on success, VERR_GETOPT_INVALID_ARGUMENT_FORMAT on
115	* failure.
116	*
117	* @param pszValue The value to convert.
118	* @param pAddr Where to store the result.
119	*/
120	static int rtgetoptConvertMacAddr(const char *pszValue, PRTMAC pAddr)
121	{
122
123	int rc = RTNetStrToMacAddr(pszValue, pAddr);
124	if (RT_FAILURE(rc))
125	return VERR_GETOPT_INVALID_ARGUMENT_FORMAT;
126
127	return VINF_SUCCESS;
128	}
129
130
131	/**
132	* Searches for a long option.
133	*
134	* @returns Pointer to a matching option.
135	* @param pszOption The alleged long option.
136	* @param paOptions Option array.
137	* @param cOptions Number of items in the array.
138	* @param fFlags Init flags.
139	*/
140	static PCRTGETOPTDEF rtGetOptSearchLong(const char *pszOption, PCRTGETOPTDEF paOptions, size_t cOptions, uint32_t fFlags)
141	{
142	PCRTGETOPTDEF pOpt = paOptions;
143	while (cOptions-- > 0)
144	{
145	if (pOpt->pszLong)
146	{
147	if ((pOpt->fFlags & RTGETOPT_REQ_MASK) != RTGETOPT_REQ_NOTHING)
148	{
149	/*
150	* A value is required with the argument. We're trying to be
151	* understanding here and will permit any of the following:
152	* --long12:value, --long12=value, --long12 value,
153	* --long:value, --long=value, --long value,
154	*
155	* If the option is index, then all trailing chars must be
156	* digits. For error reporting reasons we also match where
157	* there is no index.
158	*/
159	size_t cchLong = strlen(pOpt->pszLong);
160	if ( !strncmp(pszOption, pOpt->pszLong, cchLong)
161	\|\| ( pOpt->fFlags & RTGETOPT_FLAG_ICASE
162	&& !RTStrNICmp(pszOption, pOpt->pszLong, cchLong)))
163	{
164	if (pOpt->fFlags & RTGETOPT_FLAG_INDEX)
165	while (RT_C_IS_DIGIT(pszOption[cchLong]))
166	cchLong++;
167	if ( pszOption[cchLong] == '\0'
168	\|\| pszOption[cchLong] == ':'
169	\|\| pszOption[cchLong] == '=')
170	return pOpt;
171	}
172	}
173	else if (pOpt->fFlags & RTGETOPT_FLAG_INDEX)
174	{
175	/*
176	* The option takes an index but no value.
177	* As above, we also match where there is no index.
178	*/
179	size_t cchLong = strlen(pOpt->pszLong);
180	if ( !strncmp(pszOption, pOpt->pszLong, cchLong)
181	\|\| ( pOpt->fFlags & RTGETOPT_FLAG_ICASE
182	&& !RTStrNICmp(pszOption, pOpt->pszLong, cchLong)))
183	{
184	while (RT_C_IS_DIGIT(pszOption[cchLong]))
185	cchLong++;
186	if (pszOption[cchLong] == '\0')
187	return pOpt;
188	}
189	}
190	else if ( !strcmp(pszOption, pOpt->pszLong)
191	\|\| ( pOpt->fFlags & RTGETOPT_FLAG_ICASE
192	&& !RTStrICmp(pszOption, pOpt->pszLong)))
193	return pOpt;
194	}
195	pOpt++;
196	}
197
198	if (!(fFlags & RTGETOPTINIT_FLAGS_NO_STD_OPTS))
199	for (uint32_t i = 0; i < RT_ELEMENTS(g_aStdOptions); i++)
200	if ( !strcmp(pszOption, g_aStdOptions[i].pszLong)
201	\|\| ( g_aStdOptions[i].fFlags & RTGETOPT_FLAG_ICASE
202	&& !RTStrICmp(pszOption, g_aStdOptions[i].pszLong)))
203	return &g_aStdOptions[i];
204
205	return NULL;
206	}
207
208
209	/**
210	* Searches for a matching short option.
211	*
212	* @returns Pointer to a matching option.
213	* @param chOption The option char.
214	* @param paOptions Option array.
215	* @param cOptions Number of items in the array.
216	* @param fFlags Init flags.
217	*/
218	static PCRTGETOPTDEF rtGetOptSearchShort(int chOption, PCRTGETOPTDEF paOptions, size_t cOptions, uint32_t fFlags)
219	{
220	PCRTGETOPTDEF pOpt = paOptions;
221	while (cOptions-- > 0)
222	{
223	if (pOpt->iShort == chOption)
224	return pOpt;
225	pOpt++;
226	}
227
228	if (!(fFlags & RTGETOPTINIT_FLAGS_NO_STD_OPTS))
229	{
230	for (uint32_t i = 0; i < RT_ELEMENTS(g_aStdOptions); i++)
231	if (g_aStdOptions[i].iShort == chOption)
232	return &g_aStdOptions[i];
233	if (chOption == '?')
234	return &g_aStdOptions[RTGETOPT_STD_OPTIONS_HELP_IDX];
235	}
236	return NULL;
237	}
238
239
240	/**
241	* Value string -> Value union.
242	*
243	* @returns IPRT status code.
244	* @param fFlags The value flags.
245	* @param pszValue The value string.
246	* @param pValueUnion Where to return the processed value.
247	*/
248	static int rtGetOptProcessValue(uint32_t fFlags, const char *pszValue, PRTGETOPTUNION pValueUnion)
249	{
250	/*
251	* Transform into a option value as requested.
252	* If decimal conversion fails, we'll check for "0x<xdigit>" and
253	* try a 16 based conversion. We will not interpret any of the
254	* generic ints as octals.
255	*/
256	switch (fFlags & ( RTGETOPT_REQ_MASK
257	\| RTGETOPT_FLAG_HEX
258	\| RTGETOPT_FLAG_DEC
259	\| RTGETOPT_FLAG_OCT))
260	{
261	case RTGETOPT_REQ_STRING:
262	pValueUnion->psz = pszValue;
263	break;
264
265	case RTGETOPT_REQ_BOOL:
266	if ( !RTStrICmp(pszValue, "true")
267	\|\| !RTStrICmp(pszValue, "t")
268	\|\| !RTStrICmp(pszValue, "yes")
269	\|\| !RTStrICmp(pszValue, "y")
270	\|\| !RTStrICmp(pszValue, "enabled")
271	\|\| !RTStrICmp(pszValue, "enable")
272	\|\| !RTStrICmp(pszValue, "en")
273	\|\| !RTStrICmp(pszValue, "e")
274	\|\| !RTStrICmp(pszValue, "on")
275	\|\| !RTStrCmp(pszValue, "1")
276	)
277	pValueUnion->f = true;
278	else if ( !RTStrICmp(pszValue, "false")
279	\|\| !RTStrICmp(pszValue, "f")
280	\|\| !RTStrICmp(pszValue, "no")
281	\|\| !RTStrICmp(pszValue, "n")
282	\|\| !RTStrICmp(pszValue, "disabled")
283	\|\| !RTStrICmp(pszValue, "disable")
284	\|\| !RTStrICmp(pszValue, "dis")
285	\|\| !RTStrICmp(pszValue, "d")
286	\|\| !RTStrICmp(pszValue, "off")
287	\|\| !RTStrCmp(pszValue, "0")
288	)
289	pValueUnion->f = false;
290	else
291	{
292	pValueUnion->psz = pszValue;
293	return VERR_GETOPT_UNKNOWN_OPTION;
294	}
295	break;
296
297	case RTGETOPT_REQ_BOOL_ONOFF:
298	if (!RTStrICmp(pszValue, "on"))
299	pValueUnion->f = true;
300	else if (!RTStrICmp(pszValue, "off"))
301	pValueUnion->f = false;
302	else
303	{
304	pValueUnion->psz = pszValue;
305	return VERR_GETOPT_UNKNOWN_OPTION;
306	}
307	break;
308
309	#define MY_INT_CASE(req, type, memb, convfn) \
310	case req: \
311	{ \
312	type Value; \
313	if ( convfn(pszValue, 10, &Value) != VINF_SUCCESS \
314	&& ( pszValue[0] != '0' \
315	\|\| (pszValue[1] != 'x' && pszValue[1] != 'X') \
316	\|\| !RT_C_IS_XDIGIT(pszValue[2]) \
317	\|\| convfn(pszValue, 16, &Value) != VINF_SUCCESS ) ) \
318	return VERR_GETOPT_INVALID_ARGUMENT_FORMAT; \
319	pValueUnion->memb = Value; \
320	break; \
321	}
322	#define MY_BASE_INT_CASE(req, type, memb, convfn, base) \
323	case req: \
324	{ \
325	type Value; \
326	if (convfn(pszValue, base, &Value) != VINF_SUCCESS) \
327	return VERR_GETOPT_INVALID_ARGUMENT_FORMAT; \
328	pValueUnion->memb = Value; \
329	break; \
330	}
331
332	MY_INT_CASE(RTGETOPT_REQ_INT8, int8_t, i8, RTStrToInt8Full)
333	MY_INT_CASE(RTGETOPT_REQ_INT16, int16_t, i16, RTStrToInt16Full)
334	MY_INT_CASE(RTGETOPT_REQ_INT32, int32_t, i32, RTStrToInt32Full)
335	MY_INT_CASE(RTGETOPT_REQ_INT64, int64_t, i64, RTStrToInt64Full)
336	MY_INT_CASE(RTGETOPT_REQ_UINT8, uint8_t, u8, RTStrToUInt8Full)
337	MY_INT_CASE(RTGETOPT_REQ_UINT16, uint16_t, u16, RTStrToUInt16Full)
338	MY_INT_CASE(RTGETOPT_REQ_UINT32, uint32_t, u32, RTStrToUInt32Full)
339	MY_INT_CASE(RTGETOPT_REQ_UINT64, uint64_t, u64, RTStrToUInt64Full)
340
341	MY_BASE_INT_CASE(RTGETOPT_REQ_INT8 \| RTGETOPT_FLAG_HEX, int8_t, i8, RTStrToInt8Full, 16)
342	MY_BASE_INT_CASE(RTGETOPT_REQ_INT16 \| RTGETOPT_FLAG_HEX, int16_t, i16, RTStrToInt16Full, 16)
343	MY_BASE_INT_CASE(RTGETOPT_REQ_INT32 \| RTGETOPT_FLAG_HEX, int32_t, i32, RTStrToInt32Full, 16)
344	MY_BASE_INT_CASE(RTGETOPT_REQ_INT64 \| RTGETOPT_FLAG_HEX, int64_t, i64, RTStrToInt64Full, 16)
345	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT8 \| RTGETOPT_FLAG_HEX, uint8_t, u8, RTStrToUInt8Full, 16)
346	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT16 \| RTGETOPT_FLAG_HEX, uint16_t, u16, RTStrToUInt16Full, 16)
347	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_HEX, uint32_t, u32, RTStrToUInt32Full, 16)
348	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT64 \| RTGETOPT_FLAG_HEX, uint64_t, u64, RTStrToUInt64Full, 16)
349
350	MY_BASE_INT_CASE(RTGETOPT_REQ_INT8 \| RTGETOPT_FLAG_DEC, int8_t, i8, RTStrToInt8Full, 10)
351	MY_BASE_INT_CASE(RTGETOPT_REQ_INT16 \| RTGETOPT_FLAG_DEC, int16_t, i16, RTStrToInt16Full, 10)
352	MY_BASE_INT_CASE(RTGETOPT_REQ_INT32 \| RTGETOPT_FLAG_DEC, int32_t, i32, RTStrToInt32Full, 10)
353	MY_BASE_INT_CASE(RTGETOPT_REQ_INT64 \| RTGETOPT_FLAG_DEC, int64_t, i64, RTStrToInt64Full, 10)
354	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT8 \| RTGETOPT_FLAG_DEC, uint8_t, u8, RTStrToUInt8Full, 10)
355	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT16 \| RTGETOPT_FLAG_DEC, uint16_t, u16, RTStrToUInt16Full, 10)
356	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_DEC, uint32_t, u32, RTStrToUInt32Full, 10)
357	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT64 \| RTGETOPT_FLAG_DEC, uint64_t, u64, RTStrToUInt64Full, 10)
358
359	MY_BASE_INT_CASE(RTGETOPT_REQ_INT8 \| RTGETOPT_FLAG_OCT, int8_t, i8, RTStrToInt8Full, 8)
360	MY_BASE_INT_CASE(RTGETOPT_REQ_INT16 \| RTGETOPT_FLAG_OCT, int16_t, i16, RTStrToInt16Full, 8)
361	MY_BASE_INT_CASE(RTGETOPT_REQ_INT32 \| RTGETOPT_FLAG_OCT, int32_t, i32, RTStrToInt32Full, 8)
362	MY_BASE_INT_CASE(RTGETOPT_REQ_INT64 \| RTGETOPT_FLAG_OCT, int64_t, i64, RTStrToInt64Full, 8)
363	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT8 \| RTGETOPT_FLAG_OCT, uint8_t, u8, RTStrToUInt8Full, 8)
364	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT16 \| RTGETOPT_FLAG_OCT, uint16_t, u16, RTStrToUInt16Full, 8)
365	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_OCT, uint32_t, u32, RTStrToUInt32Full, 8)
366	MY_BASE_INT_CASE(RTGETOPT_REQ_UINT64 \| RTGETOPT_FLAG_OCT, uint64_t, u64, RTStrToUInt64Full, 8)
367
368	#undef MY_INT_CASE
369	#undef MY_BASE_INT_CASE
370
371	case RTGETOPT_REQ_IPV4ADDR:
372	{
373	RTNETADDRIPV4 Addr;
374	if (rtgetoptConvertIPv4Addr(pszValue, &Addr) != VINF_SUCCESS)
375	return VERR_GETOPT_INVALID_ARGUMENT_FORMAT;
376	pValueUnion->IPv4Addr = Addr;
377	break;
378	}
379
380	case RTGETOPT_REQ_IPV4CIDR:
381	{
382	RTNETADDRIPV4 network;
383	RTNETADDRIPV4 netmask;
384	if (RT_FAILURE(RTCidrStrToIPv4(pszValue, &network, &netmask)))
385	return VERR_GETOPT_INVALID_ARGUMENT_FORMAT;
386	pValueUnion->CidrIPv4.IPv4Network.u = network.u;
387	pValueUnion->CidrIPv4.IPv4Netmask.u = netmask.u;
388	break;
389	}
390
391	case RTGETOPT_REQ_MACADDR:
392	{
393	RTMAC Addr;
394	if (rtgetoptConvertMacAddr(pszValue, &Addr) != VINF_SUCCESS)
395	return VERR_GETOPT_INVALID_ARGUMENT_FORMAT;
396	pValueUnion->MacAddr = Addr;
397	break;
398	}
399
400	case RTGETOPT_REQ_UUID:
401	{
402	RTUUID Uuid;
403	if (RTUuidFromStr(&Uuid, pszValue) != VINF_SUCCESS)
404	return VERR_GETOPT_INVALID_ARGUMENT_FORMAT;
405	pValueUnion->Uuid = Uuid;
406	break;
407	}
408
409	default:
410	AssertMsgFailed(("f=%#x\n", fFlags));
411	return VERR_INTERNAL_ERROR;
412	}
413
414	return VINF_SUCCESS;
415	}
416
417
418	/**
419	* Moves one argv option entries.
420	*
421	* @param papszTo Destination.
422	* @param papszFrom Source.
423	*/
424	static void rtGetOptMoveArgvEntries(char papszTo, char papszFrom)
425	{
426	if (papszTo != papszFrom)
427	{
428	Assert((uintptr_t)papszTo < (uintptr_t)papszFrom);
429	char * const pszMoved = papszFrom[0];
430	memmove(&papszTo[1], &papszTo[0], (uintptr_t)papszFrom - (uintptr_t)papszTo);
431	papszTo[0] = pszMoved;
432	}
433	}
434
435
436	RTDECL(int) RTGetOpt(PRTGETOPTSTATE pState, PRTGETOPTUNION pValueUnion)
437	{
438	/*
439	* Reset the variables kept in state.
440	*/
441	pState->pDef = NULL;
442	pState->uIndex = UINT32_MAX;
443
444	/*
445	* Make sure the union is completely cleared out, whatever happens below.
446	*/
447	pValueUnion->u64 = 0;
448	pValueUnion->pDef = NULL;
449
450	/*
451	* The next option.
452	*/
453	bool fShort;
454	int iThis;
455	const char *pszArgThis;
456	PCRTGETOPTDEF pOpt;
457
458	if (pState->pszNextShort)
459	{
460	/*
461	* We've got short options left over from the previous call.
462	*/
463	pOpt = rtGetOptSearchShort(*pState->pszNextShort, pState->paOptions, pState->cOptions, pState->fFlags);
464	if (!pOpt)
465	{
466	pValueUnion->psz = pState->pszNextShort;
467	return VERR_GETOPT_UNKNOWN_OPTION;
468	}
469	pState->pszNextShort++;
470	pszArgThis = pState->pszNextShort - 2;
471	iThis = pState->iNext;
472	fShort = true;
473	}
474	else
475	{
476	/*
477	* Pop off the next argument. Sorting options and dealing with the
478	* dash-dash makes this a little extra complicated.
479	*/
480	for (;;)
481	{
482	if (pState->iNext >= pState->argc)
483	return 0;
484
485	if (pState->cNonOptions)
486	{
487	if (pState->cNonOptions == INT32_MAX)
488	{
489	pValueUnion->psz = pState->argv[pState->iNext++];
490	return VINF_GETOPT_NOT_OPTION;
491	}
492
493	if (pState->iNext + pState->cNonOptions >= pState->argc)
494	{
495	pState->cNonOptions = INT32_MAX;
496	continue;
497	}
498	}
499
500	iThis = pState->iNext++;
501	pszArgThis = pState->argv[iThis + pState->cNonOptions];
502
503	/*
504	* Do a long option search first and then a short option one.
505	* This way we can make sure single dash long options doesn't
506	* get mixed up with short ones.
507	*/
508	pOpt = rtGetOptSearchLong(pszArgThis, pState->paOptions, pState->cOptions, pState->fFlags);
509	if ( !pOpt
510	&& pszArgThis[0] == '-'
511	&& pszArgThis[1] != '-'
512	&& pszArgThis[1] != '\0')
513	{
514	pOpt = rtGetOptSearchShort(pszArgThis[1], pState->paOptions, pState->cOptions, pState->fFlags);
515	fShort = pOpt != NULL;
516	}
517	else
518	fShort = false;
519
520	/* Look for dash-dash. */
521	if (!pOpt && !strcmp(pszArgThis, "--"))
522	{
523	rtGetOptMoveArgvEntries(&pState->argv[iThis], &pState->argv[iThis + pState->cNonOptions]);
524	pState->cNonOptions = INT32_MAX;
525	continue;
526	}
527
528	/* Options first hacks. */
529	if (pState->fFlags & RTGETOPTINIT_FLAGS_OPTS_FIRST)
530	{
531	if (pOpt)
532	rtGetOptMoveArgvEntries(&pState->argv[iThis], &pState->argv[iThis + pState->cNonOptions]);
533	else if (*pszArgThis == '-')
534	{
535	pValueUnion->psz = pszArgThis;
536	return VERR_GETOPT_UNKNOWN_OPTION;
537	}
538	else
539	{
540	/* not an option, add it to the non-options and try again. */
541	pState->iNext--;
542	pState->cNonOptions++;
543
544	/* Switch to returning non-options if we've reached the end. */
545	if (pState->iNext + pState->cNonOptions >= pState->argc)
546	pState->cNonOptions = INT32_MAX;
547	continue;
548	}
549	}
550
551	/* done */
552	break;
553	}
554	}
555
556	if (pOpt)
557	{
558	pValueUnion->pDef = pOpt; /* in case of no value or error. */
559
560	if ((pOpt->fFlags & RTGETOPT_REQ_MASK) != RTGETOPT_REQ_NOTHING)
561	{
562	/*
563	* Find the argument value.
564	*
565	* A value is required with the argument. We're trying to be
566	* understanding here and will permit any of the following:
567	* -svalue, -s value, -s:value and -s=value
568	* (Ditto for long options.)
569	*/
570	const char *pszValue;
571	if (fShort)
572	{
573	if (pszArgThis[2] == '\0')
574	{
575	if (iThis + 1 >= pState->argc)
576	return VERR_GETOPT_REQUIRED_ARGUMENT_MISSING;
577	pszValue = pState->argv[iThis + pState->cNonOptions + 1];
578	rtGetOptMoveArgvEntries(&pState->argv[iThis + 1], &pState->argv[iThis + pState->cNonOptions + 1]);
579	pState->iNext++;
580	}
581	else /* same argument. */
582	pszValue = &pszArgThis[2 + (pszArgThis[2] == ':' \|\| pszArgThis[2] == '=')];
583	if (pState->pszNextShort)
584	{
585	pState->pszNextShort = NULL;
586	pState->iNext++;
587	}
588	}
589	else
590	{
591	size_t cchLong = strlen(pOpt->pszLong);
592	if (pOpt->fFlags & RTGETOPT_FLAG_INDEX)
593	{
594
595	if (pszArgThis[cchLong] == '\0')
596	return VERR_GETOPT_INDEX_MISSING;
597
598	uint32_t uIndex;
599	char *pszRet = NULL;
600	int rc = RTStrToUInt32Ex(&pszArgThis[cchLong], &pszRet, 10, &uIndex);
601	if (rc == VWRN_TRAILING_CHARS)
602	{
603	if ( pszRet[0] != ':'
604	&& pszRet[0] != '=')
605	return VERR_GETOPT_INVALID_ARGUMENT_FORMAT;
606	pState->uIndex = uIndex;
607	pszValue = pszRet + 1;
608	}
609	else if (rc == VINF_SUCCESS)
610	{
611	if (iThis + 1 >= pState->argc)
612	return VERR_GETOPT_REQUIRED_ARGUMENT_MISSING;
613	pState->uIndex = uIndex;
614	pszValue = pState->argv[iThis + pState->cNonOptions + 1];
615	rtGetOptMoveArgvEntries(&pState->argv[iThis + 1], &pState->argv[iThis + pState->cNonOptions + 1]);
616	pState->iNext++;
617	}
618	else
619	AssertMsgFailedReturn(("%s\n", pszArgThis), VERR_GETOPT_INVALID_ARGUMENT_FORMAT); /* search bug */
620	}
621	else
622	{
623	if (pszArgThis[cchLong] == '\0')
624	{
625	if (iThis + 1 >= pState->argc)
626	return VERR_GETOPT_REQUIRED_ARGUMENT_MISSING;
627	pszValue = pState->argv[iThis + pState->cNonOptions + 1];
628	rtGetOptMoveArgvEntries(&pState->argv[iThis + 1], &pState->argv[iThis + pState->cNonOptions + 1]);
629	pState->iNext++;
630	}
631	else /* same argument. */
632	pszValue = &pszArgThis[cchLong + 1];
633	}
634	}
635
636	/*
637	* Set up the ValueUnion.
638	*/
639	int rc = rtGetOptProcessValue(pOpt->fFlags, pszValue, pValueUnion);
640	if (RT_FAILURE(rc))
641	return rc;
642	}
643	else if (fShort)
644	{
645	/*
646	* Deal with "compressed" short option lists, correcting the next
647	* state variables for the start and end cases.
648	*/
649	if (pszArgThis[2])
650	{
651	if (!pState->pszNextShort)
652	{
653	/* start */
654	pState->pszNextShort = &pszArgThis[2];
655	pState->iNext--;
656	}
657	}
658	else if (pState->pszNextShort)
659	{
660	/* end */
661	pState->pszNextShort = NULL;
662	pState->iNext++;
663	}
664	}
665	else if (pOpt->fFlags & RTGETOPT_FLAG_INDEX)
666	{
667	size_t cchLong = strlen(pOpt->pszLong);
668	if (pszArgThis[cchLong] == '\0')
669	return VERR_GETOPT_INDEX_MISSING;
670
671	uint32_t uIndex;
672	if (RTStrToUInt32Full(&pszArgThis[cchLong], 10, &uIndex) == VINF_SUCCESS)
673	pState->uIndex = uIndex;
674	else
675	AssertMsgFailedReturn(("%s\n", pszArgThis), VERR_GETOPT_INVALID_ARGUMENT_FORMAT); /* search bug */
676	}
677
678	pState->pDef = pOpt;
679	return pOpt->iShort;
680	}
681
682	/*
683	* Not a known option argument. If it starts with a switch char (-) we'll
684	* fail with unknown option, and if it doesn't we'll return it as a non-option.
685	*/
686	if (*pszArgThis == '-')
687	{
688	pValueUnion->psz = pszArgThis;
689	return VERR_GETOPT_UNKNOWN_OPTION;
690	}
691
692	pValueUnion->psz = pszArgThis;
693	return VINF_GETOPT_NOT_OPTION;
694	}
695	RT_EXPORT_SYMBOL(RTGetOpt);
696
697
698	RTDECL(int) RTGetOptFetchValue(PRTGETOPTSTATE pState, PRTGETOPTUNION pValueUnion, uint32_t fFlags)
699	{
700	/*
701	* Validate input.
702	*/
703	PCRTGETOPTDEF pOpt = pState->pDef;
704	AssertReturn(!(fFlags & ~RTGETOPT_VALID_MASK), VERR_INVALID_PARAMETER);
705	AssertReturn((fFlags & RTGETOPT_REQ_MASK) != RTGETOPT_REQ_NOTHING, VERR_INVALID_PARAMETER);
706
707	/*
708	* Make sure the union is completely cleared out, whatever happens below.
709	*/
710	pValueUnion->u64 = 0;
711	pValueUnion->pDef = NULL;
712
713	/*
714	* Pop off the next argument and convert it into a value union.
715	*/
716	if (pState->iNext >= pState->argc)
717	return VERR_GETOPT_REQUIRED_ARGUMENT_MISSING;
718	int iThis = pState->iNext++;
719	const char *pszValue = pState->argv[iThis + (pState->cNonOptions != INT32_MAX ? pState->cNonOptions : 0)];
720	pValueUnion->pDef = pOpt; /* in case of no value or error. */
721
722	if (pState->cNonOptions && pState->cNonOptions != INT32_MAX)
723	rtGetOptMoveArgvEntries(&pState->argv[iThis], &pState->argv[iThis + pState->cNonOptions]);
724
725	return rtGetOptProcessValue(fFlags, pszValue, pValueUnion);
726	}
727	RT_EXPORT_SYMBOL(RTGetOptFetchValue);
728
729
730	RTDECL(RTEXITCODE) RTGetOptPrintError(int ch, PCRTGETOPTUNION pValueUnion)
731	{
732	if (ch == VINF_GETOPT_NOT_OPTION)
733	RTMsgError("Invalid parameter: %s", pValueUnion->psz);
734	else if (ch > 0)
735	{
736	if (RT_C_IS_GRAPH(ch))
737	RTMsgError("Unhandled option: -%c", ch);
738	else
739	RTMsgError("Unhandled option: %i (%#x)", ch, ch);
740	}
741	else if (ch == VERR_GETOPT_UNKNOWN_OPTION)
742	RTMsgError("Unknown option: '%s'", pValueUnion->psz);
743	else if (pValueUnion->pDef && ch == VERR_GETOPT_INVALID_ARGUMENT_FORMAT)
744	/** @todo r=klaus not really ideal, as the value isn't available */
745	RTMsgError("The value given '%s' has an invalid format.", pValueUnion->pDef->pszLong);
746	else if (pValueUnion->pDef)
747	RTMsgError("%s: %Rrs\n", pValueUnion->pDef->pszLong, ch);
748	else
749	RTMsgError("%Rrs\n", ch);
750
751	return RTEXITCODE_SYNTAX;
752	}
753	RT_EXPORT_SYMBOL(RTGetOptPrintError);
754

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/misc/getopt.cpp@ 62559

Download in other formats: