getoptargv.cpp

Last change on this file was 106061, checked in by vboxsync, 8 weeks ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.0 KB

Line
1	/* $Id: getoptargv.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* IPRT - Command Line Parsing, Argument Vector.
4	*/
5
6	/*
7	* Copyright (C) 2010-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include <iprt/getopt.h>
42	#include "internal/iprt.h"
43
44	#include <iprt/asm.h>
45	#include <iprt/assert.h>
46	#include <iprt/err.h>
47	#include <iprt/mem.h>
48	#include <iprt/string.h>
49
50
51	/*********************************************************************************************************************************
52	* Header Files *
53	*********************************************************************************************************************************/
54	/** @todo move to cdefs.h */
55	#ifdef __GNUC__
56	# define DECL_VAR_ALIGNED(a_Scope, a_Type, a_Name, a_Alignment) a_Scope a_Type a_Name __attribute__((__aligned__(a_Alignment)))
57	#elif defined(_MSC_VER)
58	# define DECL_VAR_ALIGNED(a_Scope, a_Type, a_Name, a_Alignment) a_Scope __declspec(align(a_Alignment)) a_Type a_Name
59	#else
60	# define DECL_VAR_ALIGNED(a_Scope, a_Type, a_Name, a_Alignment) a_Scope a_Type a_Name
61	#endif
62
63	/**
64	* Array indexed by the quoting type and 7-bit ASCII character.
65	*
66	* We include some extra stuff here that the corresponding shell would normally
67	* require quoting of.
68	*
69	* @note We 16-byte align this as ASMBitSet/ASMBitTest expects aligned data, and
70	* with a uint8_t type the compiler/linker may use byte alignment.
71	*/
72	#ifndef IPRT_REGENERATE_QUOTE_CHARS
73	DECL_VAR_ALIGNED(static, uint8_t const, g_abmQuoteChars[RTGETOPTARGV_CNV_QUOTE_MASK + 1][16], 16) =
74	#else
75	DECL_VAR_ALIGNED(static, uint8_t, g_abmQuoteChars[RTGETOPTARGV_CNV_QUOTE_MASK + 1][16], 16) =
76	#endif
77	{
78	{ 0xfe, 0xff, 0xff, 0xff, 0x65, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 },
79	{ 0xfe, 0xff, 0xff, 0xff, 0xd7, 0x07, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x50 },
80	};
81
82
83	#ifdef IPRT_REGENERATE_QUOTE_CHARS /* To re-generate the bitmaps. */
84	# include <stdio.h>
85	int main()
86	{
87	RT_ZERO(g_abmQuoteChars);
88
89	# define SET_ALL(ch) \
90	do { \
91	for (size_t iType = 0; iType <= RTGETOPTARGV_CNV_QUOTE_MASK; iType++) \
92	ASMBitSet(&g_abmQuoteChars[iType], (ch)); \
93	} while (0)
94	# define SET(ConstSuffix, ch) \
95	do { \
96	ASMBitSet(&g_abmQuoteChars[RTGETOPTARGV_CNV_QUOTE_##ConstSuffix], (ch)); \
97	printf(#ConstSuffix ": %#x %d %c\n", (ch), (ch), (ch)); \
98	} while (0)
99
100	/* just flag all the control chars as in need of quoting. */
101	for (char ch = 1; ch < 0x20; ch++)
102	SET_ALL(ch);
103
104	/* ... and space of course */
105	SET_ALL(' ');
106
107	/* MS CRT / CMD.EXE: */
108	SET(MS_CRT, '"');
109	SET(MS_CRT, '&');
110	SET(MS_CRT, '>');
111	SET(MS_CRT, '<');
112	SET(MS_CRT, '\|');
113	SET(MS_CRT, '%');
114
115	/* Bourne shell: */
116	SET(BOURNE_SH, '!');
117	SET(BOURNE_SH, '"');
118	SET(BOURNE_SH, '$');
119	SET(BOURNE_SH, '&');
120	SET(BOURNE_SH, '(');
121	SET(BOURNE_SH, ')');
122	SET(BOURNE_SH, '*');
123	SET(BOURNE_SH, ';');
124	SET(BOURNE_SH, '<');
125	SET(BOURNE_SH, '>');
126	SET(BOURNE_SH, '?');
127	SET(BOURNE_SH, '[');
128	SET(BOURNE_SH, '\'');
129	SET(BOURNE_SH, '\\');
130	SET(BOURNE_SH, '`');
131	SET(BOURNE_SH, '\|');
132	SET(BOURNE_SH, '~');
133
134	for (size_t iType = 0; iType <= RTGETOPTARGV_CNV_QUOTE_MASK; iType++)
135	{
136	printf(" {");
137	for (size_t iByte = 0; iByte < 16; iByte++)
138	printf(iByte == 0 ? " 0x%02x" : ", 0x%02x", g_abmQuoteChars[iType][iByte]);
139	printf(" },\n");
140	}
141	return 0;
142	}
143
144	#else /* !IPRT_REGENERATE_QUOTE_CHARS */
145
146	/**
147	* Look for an unicode code point in the separator string.
148	*
149	* @returns true if it's a separator, false if it isn't.
150	* @param Cp The code point.
151	* @param pszSeparators The separators.
152	*/
153	static bool rtGetOptIsUniCpInString(RTUNICP Cp, const char *pszSeparators)
154	{
155	/* This could be done in a more optimal fashion. Probably worth a
156	separate RTStr function at some point. */
157	for (;;)
158	{
159	RTUNICP CpSep;
160	int rc = RTStrGetCpEx(&pszSeparators, &CpSep);
161	AssertRCReturn(rc, false);
162	if (CpSep == Cp)
163	return true;
164	if (!CpSep)
165	return false;
166	}
167	}
168
169
170	/**
171	* Look for an 7-bit ASCII character in the separator string.
172	*
173	* @returns true if it's a separator, false if it isn't.
174	* @param ch The character.
175	* @param pszSeparators The separators.
176	* @param cchSeparators The number of separators chars.
177	*/
178	DECLINLINE(bool) rtGetOptIsAsciiInSet(char ch, const char *pszSeparators, size_t cchSeparators)
179	{
180	switch (cchSeparators)
181	{
182	case 8: if (ch == pszSeparators[7]) return true; RT_FALL_THRU();
183	case 7: if (ch == pszSeparators[6]) return true; RT_FALL_THRU();
184	case 6: if (ch == pszSeparators[5]) return true; RT_FALL_THRU();
185	case 5: if (ch == pszSeparators[4]) return true; RT_FALL_THRU();
186	case 4: if (ch == pszSeparators[3]) return true; RT_FALL_THRU();
187	case 3: if (ch == pszSeparators[2]) return true; RT_FALL_THRU();
188	case 2: if (ch == pszSeparators[1]) return true; RT_FALL_THRU();
189	case 1: if (ch == pszSeparators[0]) return true;
190	return false;
191	default:
192	return memchr(pszSeparators, ch, cchSeparators) != NULL;
193	}
194	}
195
196
197	/**
198	* Checks if the character is in the set of separators
199	*
200	* @returns true if it is, false if it isn't.
201	*
202	* @param Cp The code point.
203	* @param pszSeparators The separators.
204	* @param cchSeparators The length of @a pszSeparators.
205	*/
206	DECL_FORCE_INLINE(bool) rtGetOptIsCpInSet(RTUNICP Cp, const char *pszSeparators, size_t cchSeparators)
207	{
208	if (RT_LIKELY(Cp <= 127))
209	return rtGetOptIsAsciiInSet((char)Cp, pszSeparators, cchSeparators);
210	return rtGetOptIsUniCpInString(Cp, pszSeparators);
211	}
212
213
214	/**
215	* Skips any delimiters at the start of the string that is pointed to.
216	*
217	* @returns VINF_SUCCESS or RTStrGetCpEx status code.
218	* @param ppszSrc Where to get and return the string pointer.
219	* @param pszSeparators The separators.
220	* @param cchSeparators The length of @a pszSeparators.
221	*/
222	static int rtGetOptSkipDelimiters(const char *ppszSrc, const char pszSeparators, size_t cchSeparators)
223	{
224	const char pszSrc = ppszSrc;
225	const char *pszRet;
226	for (;;)
227	{
228	pszRet = pszSrc;
229	RTUNICP Cp;
230	int rc = RTStrGetCpEx(&pszSrc, &Cp);
231	if (RT_FAILURE(rc))
232	{
233	*ppszSrc = pszRet;
234	return rc;
235	}
236	if ( !Cp
237	\|\| !rtGetOptIsCpInSet(Cp, pszSeparators, cchSeparators))
238	break;
239	}
240
241	*ppszSrc = pszRet;
242	return VINF_SUCCESS;
243	}
244
245
246	RTDECL(int) RTGetOptArgvFromString(char **ppapszArgv, int pcArgs, const char *pszCmdLine,
247	uint32_t fFlags, const char *pszSeparators)
248	{
249	/*
250	* Some input validation.
251	*/
252	AssertPtr(pszCmdLine);
253	AssertPtr(pcArgs);
254	AssertPtr(ppapszArgv);
255	AssertReturn( (fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) == RTGETOPTARGV_CNV_QUOTE_BOURNE_SH
256	\|\| (fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) == RTGETOPTARGV_CNV_QUOTE_MS_CRT, VERR_INVALID_FLAGS);
257	AssertReturn(~(fFlags & ~RTGETOPTARGV_CNV_VALID_MASK), VERR_INVALID_FLAGS);
258
259	if (!pszSeparators)
260	pszSeparators = " \t\n\r";
261	else
262	AssertPtr(pszSeparators);
263	size_t const cchSeparators = strlen(pszSeparators);
264	AssertReturn(cchSeparators > 0, VERR_INVALID_PARAMETER);
265
266	/*
267	* Parse the command line and chop off it into argv individual argv strings.
268	*/
269	const char *pszSrc = pszCmdLine;
270	char *pszDup = NULL;
271	char *pszDst;
272	if (fFlags & RTGETOPTARGV_CNV_MODIFY_INPUT)
273	pszDst = (char *)pszCmdLine;
274	else
275	{
276	pszDst = pszDup = (char *)RTMemAlloc(strlen(pszSrc) + 1);
277	if (!pszDup)
278	return VERR_NO_STR_MEMORY;
279	}
280	int rc = VINF_SUCCESS;
281	char **papszArgs = NULL;
282	unsigned iArg = 0;
283	while (*pszSrc)
284	{
285	/* Skip stuff */
286	rc = rtGetOptSkipDelimiters(&pszSrc, pszSeparators, cchSeparators);
287	if (RT_FAILURE(rc))
288	break;
289	if (!*pszSrc)
290	break;
291
292	/* Start a new entry. */
293	if ((iArg % 32) == 0)
294	{
295	void pvNew = RTMemRealloc(papszArgs, (iArg + 33) sizeof(char *));
296	if (!pvNew)
297	{
298	rc = VERR_NO_MEMORY;
299	break;
300	}
301	papszArgs = (char **)pvNew;
302	}
303	papszArgs[iArg++] = pszDst;
304
305	/*
306	* Parse and copy the string over.
307	*/
308	RTUNICP uc;
309	if ((fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) == RTGETOPTARGV_CNV_QUOTE_BOURNE_SH)
310	{
311	/*
312	* Bourne shell style.
313	*/
314	RTUNICP ucQuote = 0;
315	for (;;)
316	{
317	rc = RTStrGetCpEx(&pszSrc, &uc);
318	if (RT_FAILURE(rc) \|\| !uc)
319	break;
320	if (!ucQuote)
321	{
322	if (uc == '"' \|\| uc == '\'')
323	ucQuote = uc;
324	else if (rtGetOptIsCpInSet(uc, pszSeparators, cchSeparators))
325	break;
326	else if (uc != '\\')
327	pszDst = RTStrPutCp(pszDst, uc);
328	else
329	{
330	/* escaped char */
331	rc = RTStrGetCpEx(&pszSrc, &uc);
332	if (RT_FAILURE(rc) \|\| !uc)
333	break;
334	pszDst = RTStrPutCp(pszDst, uc);
335	}
336	}
337	else if (ucQuote != uc)
338	{
339	if (uc != '\\' \|\| ucQuote == '\'')
340	pszDst = RTStrPutCp(pszDst, uc);
341	else
342	{
343	/* escaped char */
344	rc = RTStrGetCpEx(&pszSrc, &uc);
345	if (RT_FAILURE(rc) \|\| !uc)
346	break;
347	if ( uc != '"'
348	&& uc != '\\'
349	&& uc != '`'
350	&& uc != '$'
351	&& uc != '\n')
352	pszDst = RTStrPutCp(pszDst, ucQuote);
353	pszDst = RTStrPutCp(pszDst, uc);
354	}
355	}
356	else
357	ucQuote = 0;
358	}
359	}
360	else
361	{
362	/*
363	* Microsoft CRT style.
364	*/
365	Assert((fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) == RTGETOPTARGV_CNV_QUOTE_MS_CRT);
366	bool fInQuote = false;
367	for (;;)
368	{
369	rc = RTStrGetCpEx(&pszSrc, &uc);
370	if (RT_FAILURE(rc) \|\| !uc)
371	break;
372	if (uc == '"')
373	{
374	/* Two double quotes insides a quoted string in an escape
375	sequence and we output one double quote char.
376	See http://www.daviddeley.com/autohotkey/parameters/parameters.htm */
377	if (!fInQuote)
378	fInQuote = true;
379	else if (*pszSrc != '"')
380	fInQuote = false;
381	else
382	{
383	pszDst = RTStrPutCp(pszDst, '"');
384	pszSrc++;
385	}
386	}
387	else if (!fInQuote && rtGetOptIsCpInSet(uc, pszSeparators, cchSeparators))
388	break;
389	else if (uc != '\\')
390	pszDst = RTStrPutCp(pszDst, uc);
391	else
392	{
393	/* A backslash sequence is only relevant if followed by
394	a double quote, then it will work like an escape char. */
395	size_t cSlashes = 1;
396	while (*pszSrc == '\\')
397	{
398	cSlashes++;
399	pszSrc++;
400	}
401	if (*pszSrc != '"')
402	/* Not an escape sequence. */
403	while (cSlashes-- > 0)
404	pszDst = RTStrPutCp(pszDst, '\\');
405	else
406	{
407	/* Escape sequence. Output half of the slashes. If odd
408	number, output the escaped double quote . */
409	while (cSlashes >= 2)
410	{
411	pszDst = RTStrPutCp(pszDst, '\\');
412	cSlashes -= 2;
413	}
414	if (cSlashes)
415	{
416	pszDst = RTStrPutCp(pszDst, '"');
417	pszSrc++;
418	}
419	}
420	}
421	}
422	}
423
424	*pszDst++ = '\0';
425	if (RT_FAILURE(rc) \|\| !uc)
426	break;
427	}
428
429	if (RT_FAILURE(rc))
430	{
431	RTMemFree(pszDup);
432	RTMemFree(papszArgs);
433	return rc;
434	}
435
436	/*
437	* Terminate the array.
438	* Check for empty string to make sure we've got an array.
439	*/
440	if (iArg == 0)
441	{
442	RTMemFree(pszDup);
443	papszArgs = (char *)RTMemAlloc(1 sizeof(char *));
444	if (!papszArgs)
445	return VERR_NO_MEMORY; /* (parfait is wrong about leak here (of other papszArgs alloc)) */
446	}
447	papszArgs[iArg] = NULL;
448
449	*pcArgs = iArg;
450	*ppapszArgv = papszArgs;
451	return VINF_SUCCESS; /* (parfait is wrong about any pszDup & papszArgv leaks here, they are intentional) */
452	}
453
454
455	RTDECL(void) RTGetOptArgvFree(char **papszArgv)
456	{
457	RTGetOptArgvFreeEx(papszArgv, 0);
458	}
459
460
461	RTDECL(void) RTGetOptArgvFreeEx(char **papszArgv, uint32_t fFlags)
462	{
463	Assert(~(fFlags & ~RTGETOPTARGV_CNV_VALID_MASK));
464	if (papszArgv)
465	{
466	/*
467	* We've really only _two_ allocations here. Check the code in
468	* RTGetOptArgvFromString for the particulars.
469	*/
470	if (!(fFlags & RTGETOPTARGV_CNV_MODIFY_INPUT))
471	RTMemFree(papszArgv[0]);
472	RTMemFree(papszArgv);
473	}
474	}
475
476
477	/**
478	* Checks if the argument needs quoting or not.
479	*
480	* @returns true if it needs, false if it don't.
481	* @param pszArg The argument.
482	* @param fFlags Quoting style.
483	* @param pcch Where to store the argument length when quoting
484	* is not required. (optimization)
485	*/
486	DECLINLINE(bool) rtGetOpArgvRequiresQuoting(const char pszArg, uint32_t fFlags, size_t pcch)
487	{
488	if ((fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) != RTGETOPTARGV_CNV_UNQUOTED)
489	{
490	char const *psz = pszArg;
491	unsigned char ch;
492	while ((ch = (unsigned char)*psz))
493	{
494	if ( ch < 128
495	&& ASMBitTest(&g_abmQuoteChars[fFlags & RTGETOPTARGV_CNV_QUOTE_MASK], ch))
496	return true;
497	psz++;
498	}
499
500	*pcch = psz - pszArg;
501	}
502	else
503	*pcch = strlen(pszArg);
504	return false;
505	}
506
507
508	/**
509	* Grows the command line string buffer.
510	*
511	* @returns VINF_SUCCESS or VERR_NO_STR_MEMORY.
512	* @param ppszCmdLine Pointer to the command line string pointer.
513	* @param pcbCmdLineAlloc Pointer to the allocation length variable.
514	* @param cchMin The minimum size to grow with, kind of.
515	*/
516	static int rtGetOptArgvToStringGrow(char *ppszCmdLine, size_t pcbCmdLineAlloc, size_t cchMin)
517	{
518	size_t cb = *pcbCmdLineAlloc;
519	while (cb < cchMin)
520	cb *= 2;
521	cb *= 2;
522	*pcbCmdLineAlloc = cb;
523	return RTStrRealloc(ppszCmdLine, cb);
524	}
525
526	/**
527	* Checks if we have a sequence of DOS slashes followed by a double quote char.
528	*
529	* @returns true / false accordingly.
530	* @param psz The string.
531	*/
532	DECLINLINE(bool) rtGetOptArgvMsCrtIsSlashQuote(const char *psz)
533	{
534	while (*psz == '\\')
535	psz++;
536	return psz == '"' \|\| psz == '\0';
537	}
538
539
540	RTDECL(int) RTGetOptArgvToString(char *ppszCmdLine, const char const *papszArgv, uint32_t fFlags)
541	{
542	AssertReturn((fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) <= RTGETOPTARGV_CNV_UNQUOTED, VERR_INVALID_FLAGS);
543	AssertReturn(!(fFlags & (~RTGETOPTARGV_CNV_VALID_MASK \| RTGETOPTARGV_CNV_MODIFY_INPUT)), VERR_INVALID_FLAGS);
544
545	#define PUT_CH(ch) \
546	if (RT_UNLIKELY(off + 1 >= cbCmdLineAlloc)) { \
547	rc = rtGetOptArgvToStringGrow(&pszCmdLine, &cbCmdLineAlloc, 1); \
548	if (RT_FAILURE(rc)) \
549	break; \
550	} \
551	pszCmdLine[off++] = (ch)
552
553	#define PUT_PSZ(psz, cch) \
554	if (RT_UNLIKELY(off + (cch) >= cbCmdLineAlloc)) { \
555	rc = rtGetOptArgvToStringGrow(&pszCmdLine, &cbCmdLineAlloc, (cch)); \
556	if (RT_FAILURE(rc)) \
557	break; \
558	} \
559	memcpy(&pszCmdLine[off], (psz), (cch)); \
560	off += (cch);
561	#define PUT_SZ(sz) PUT_PSZ(sz, sizeof(sz) - 1)
562
563	/*
564	* Take the realloc approach, it requires less code and is probably more
565	* efficient than figuring out the size first.
566	*/
567	int rc = VINF_SUCCESS;
568	size_t off = 0;
569	size_t cbCmdLineAlloc = 256;
570	char *pszCmdLine = RTStrAlloc(256);
571	if (!pszCmdLine)
572	return VERR_NO_STR_MEMORY;
573
574	for (size_t i = 0; papszArgv[i]; i++)
575	{
576	if (i > 0)
577	{
578	PUT_CH(' ');
579	}
580
581	/* does it need quoting? */
582	const char *pszArg = papszArgv[i];
583	size_t cchArg;
584	if (!rtGetOpArgvRequiresQuoting(pszArg, fFlags, &cchArg))
585	{
586	/* No quoting needed, just append the argument. */
587	PUT_PSZ(pszArg, cchArg);
588	}
589	else if ((fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) == RTGETOPTARGV_CNV_QUOTE_MS_CRT)
590	{
591	/*
592	* Microsoft CRT quoting. Quote the whole argument in double
593	* quotes to make it easier to read and code.
594	*/
595	PUT_CH('"');
596	char ch;
597	while ((ch = *pszArg++))
598	{
599	if ( ch == '\\'
600	&& rtGetOptArgvMsCrtIsSlashQuote(pszArg))
601	{
602	PUT_SZ("\\\\");
603	}
604	else if (ch == '"')
605	{
606	PUT_SZ("\\\"");
607	}
608	else
609	{
610	PUT_CH(ch);
611	}
612	}
613	PUT_CH('"');
614	}
615	else
616	{
617	/*
618	* Bourne Shell quoting. Quote the whole thing in single quotes
619	* and use double quotes for any single quote chars.
620	*/
621	PUT_CH('\'');
622	char ch;
623	while ((ch = *pszArg++))
624	{
625	if (ch == '\'')
626	{
627	PUT_SZ("'\"'\"'");
628	}
629	else
630	{
631	PUT_CH(ch);
632	}
633	}
634	PUT_CH('\'');
635	}
636	}
637
638	/* Set return value / cleanup. */
639	if (RT_SUCCESS(rc))
640	{
641	pszCmdLine[off] = '\0';
642	*ppszCmdLine = pszCmdLine;
643	}
644	else
645	RTStrFree(pszCmdLine);
646	#undef PUT_SZ
647	#undef PUT_PSZ
648	#undef PUT_CH
649	return rc;
650	}
651
652
653	RTDECL(int) RTGetOptArgvToUtf16String(PRTUTF16 ppwszCmdLine, const char const *papszArgv, uint32_t fFlags)
654	{
655	char *pszCmdLine;
656	int rc = RTGetOptArgvToString(&pszCmdLine, papszArgv, fFlags);
657	if (RT_SUCCESS(rc))
658	{
659	rc = RTStrToUtf16(pszCmdLine, ppwszCmdLine);
660	RTStrFree(pszCmdLine);
661	}
662	return rc;
663	}
664
665	#endif /* !IPRT_REGENERATE_QUOTE_CHARS */
666

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

source: vbox/trunk/src/VBox/Runtime/common/misc/getoptargv.cpp

Download in other formats: