RTPathParse.cpp.h@ 100031

Last change on this file since 100031 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 8.1 KB

Line
1	/* $Id: RTPathParse.cpp.h 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* IPRT - RTPathParse - Code Template.
4	*
5	* This file included multiple times with different path style macros.
6	*/
7
8	/*
9	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
10	*
11	* This file is part of VirtualBox base platform packages, as
12	* available from https://www.virtualbox.org.
13	*
14	* This program is free software; you can redistribute it and/or
15	* modify it under the terms of the GNU General Public License
16	* as published by the Free Software Foundation, in version 3 of the
17	* License.
18	*
19	* This program is distributed in the hope that it will be useful, but
20	* WITHOUT ANY WARRANTY; without even the implied warranty of
21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22	* General Public License for more details.
23	*
24	* You should have received a copy of the GNU General Public License
25	* along with this program; if not, see <https://www.gnu.org/licenses>.
26	*
27	* The contents of this file may alternatively be used under the terms
28	* of the Common Development and Distribution License Version 1.0
29	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
30	* in the VirtualBox distribution, in which case the provisions of the
31	* CDDL are applicable instead of those of the GPL.
32	*
33	* You may elect to license modified versions of this file under the
34	* terms and conditions of either the GPL or the CDDL or both.
35	*
36	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
37	*/
38
39
40
41	/**
42	* @copydoc RTPathParse
43	*/
44	static int RTPATH_STYLE_FN(rtPathParse)(const char *pszPath, PRTPATHPARSED pParsed, size_t cbParsed, uint32_t fFlags)
45	{
46	/*
47	* Parse the root specification if present and initialize the parser state
48	* (keep it on the stack for speed).
49	*/
50	uint32_t const cMaxComps = cbParsed < RT_UOFFSETOF(RTPATHPARSED, aComps[0xfff0])
51	? (uint32_t)((cbParsed - RT_UOFFSETOF(RTPATHPARSED, aComps)) / sizeof(pParsed->aComps[0]))
52	: 0xfff0;
53	uint32_t idxComp = 0;
54	uint32_t cchPath;
55	uint32_t offCur;
56	uint16_t fProps;
57
58	if (RTPATH_IS_SLASH(pszPath[0]))
59	{
60	if (fFlags & RTPATH_STR_F_NO_START)
61	{
62	offCur = 1;
63	while (RTPATH_IS_SLASH(pszPath[offCur]))
64	offCur++;
65	if (!pszPath[offCur])
66	return VERR_PATH_ZERO_LENGTH;
67	fProps = RTPATH_PROP_RELATIVE \| RTPATH_PROP_EXTRA_SLASHES;
68	cchPath = 0;
69	}
70	#if RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS
71	else if (RTPATH_IS_SLASH(pszPath[1]))
72	{
73	/* UNC - there are exactly two prefix slashes followed by a namespace
74	or computer name, which can be empty on windows. */
75	offCur = 2;
76	while (!RTPATH_IS_SLASH(pszPath[offCur]) && pszPath[offCur])
77	offCur++;
78
79	/* Special fun for windows. */
80	fProps = RTPATH_PROP_UNC \| RTPATH_PROP_ABSOLUTE;
81	if ( offCur == 3
82	&& (pszPath[2] == '.' \|\| pszPath[2] == '?'))
83	fProps \|= RTPATH_PROP_SPECIAL_UNC;
84
85	if (RTPATH_IS_SLASH(pszPath[offCur]))
86	{
87	fProps \|= RTPATH_PROP_ROOT_SLASH;
88	offCur++;
89	}
90	cchPath = offCur;
91	}
92	#endif
93	else
94	{
95	#if RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS
96	fProps = RTPATH_PROP_ROOT_SLASH \| RTPATH_PROP_RELATIVE;
97	#else
98	fProps = RTPATH_PROP_ROOT_SLASH \| RTPATH_PROP_ABSOLUTE;
99	#endif
100	offCur = 1;
101	cchPath = 1;
102	}
103	}
104	#if RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS
105	else if (RT_C_IS_ALPHA(pszPath[0]) && pszPath[1] == ':')
106	{
107	if (!RTPATH_IS_SLASH(pszPath[2]))
108	{
109	fProps = RTPATH_PROP_VOLUME \| RTPATH_PROP_RELATIVE;
110	offCur = 2;
111	}
112	else
113	{
114	fProps = RTPATH_PROP_VOLUME \| RTPATH_PROP_ROOT_SLASH \| RTPATH_PROP_ABSOLUTE;
115	offCur = 3;
116	}
117	cchPath = offCur;
118	}
119	#endif
120	else
121	{
122	fProps = RTPATH_PROP_RELATIVE;
123	offCur = 0;
124	cchPath = 0;
125	}
126
127	/* Add it to the component array . */
128	if (offCur && !(fFlags & RTPATH_STR_F_NO_START))
129	{
130	cchPath = offCur;
131	if (idxComp < cMaxComps)
132	{
133	pParsed->aComps[idxComp].off = 0;
134	pParsed->aComps[idxComp].cch = offCur;
135	}
136	idxComp++;
137
138	/* Skip unnecessary slashes following the root-spec. */
139	if (RTPATH_IS_SLASH(pszPath[offCur]))
140	{
141	fProps \|= RTPATH_PROP_EXTRA_SLASHES;
142	do
143	offCur++;
144	while (RTPATH_IS_SLASH(pszPath[offCur]));
145	}
146	}
147
148	/*
149	* Parse the rest.
150	*/
151	if (pszPath[offCur])
152	{
153	for (;;)
154	{
155	Assert(!RTPATH_IS_SLASH(pszPath[offCur]));
156
157	/* Find the end of the component. */
158	uint32_t offStart = offCur;
159	char ch;
160	while ((ch = pszPath[offCur]) != '\0' && !RTPATH_IS_SLASH(ch))
161	offCur++;
162	if (offCur >= _64K)
163	return VERR_FILENAME_TOO_LONG;
164
165	/* Add it. */
166	uint32_t cchComp = offCur - offStart;
167	if (idxComp < cMaxComps)
168	{
169	pParsed->aComps[idxComp].off = offStart;
170	pParsed->aComps[idxComp].cch = cchComp;
171	}
172	idxComp++;
173	cchPath += cchComp;
174
175	/* Look for '.' and '..' references. */
176	if (cchComp == 1 && pszPath[offCur - 1] == '.')
177	fProps \|= RTPATH_PROP_DOT_REFS;
178	else if (cchComp == 2 && pszPath[offCur - 1] == '.' && pszPath[offCur - 2] == '.')
179	{
180	fProps &= ~RTPATH_PROP_ABSOLUTE;
181	fProps \|= RTPATH_PROP_DOTDOT_REFS \| RTPATH_PROP_RELATIVE;
182	}
183
184	/* Skip unnecessary slashes. Leave ch unchanged! */
185	char ch2 = ch;
186	if (ch2)
187	{
188	ch2 = pszPath[++offCur];
189	if (RTPATH_IS_SLASH(ch2))
190	{
191	fProps \|= RTPATH_PROP_EXTRA_SLASHES;
192	do
193	ch2 = pszPath[++offCur];
194	while (RTPATH_IS_SLASH(ch2));
195	}
196	}
197
198	/* The end? */
199	if (ch2 == '\0')
200	{
201	pParsed->offSuffix = offCur;
202	pParsed->cchSuffix = 0;
203	if (ch)
204	{
205	if (!(fFlags & RTPATH_STR_F_NO_END))
206	{
207	fProps \|= RTPATH_PROP_DIR_SLASH; /* (not counted in component, but in cchPath) */
208	cchPath++;
209	}
210	else
211	fProps \|= RTPATH_PROP_EXTRA_SLASHES;
212	}
213	else if (!(fFlags & RTPATH_STR_F_NO_END))
214	{
215	fProps \|= RTPATH_PROP_FILENAME;
216
217	/* Look for a suffix: */
218	uint32_t offSuffix = offStart + cchComp;
219	while (--offSuffix > offStart)
220	if (pszPath[offSuffix] == '.')
221	{
222	uint32_t cchSuffix = offStart + cchComp - offSuffix;
223	if (cchSuffix > 1)
224	{
225	pParsed->cchSuffix = cchSuffix;
226	pParsed->offSuffix = offSuffix;
227	fProps \|= RTPATH_PROP_SUFFIX;
228	}
229	break;
230	}
231	}
232	break;
233	}
234
235	/* No, not the end. Account for an separator before we restart the loop. */
236	cchPath += sizeof(RTPATH_SLASH_STR) - 1;
237	}
238	}
239	else
240	{
241	pParsed->offSuffix = offCur;
242	pParsed->cchSuffix = 0;
243	}
244	if (offCur >= _64K)
245	return VERR_FILENAME_TOO_LONG;
246
247	/*
248	* Store the remainder of the state and we're done.
249	*/
250	pParsed->fProps = fProps;
251	pParsed->cchPath = cchPath;
252	pParsed->cComps = idxComp;
253
254	return idxComp <= cMaxComps ? VINF_SUCCESS : VERR_BUFFER_OVERFLOW;
255	}
256

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

source: vbox/trunk/src/VBox/Runtime/common/path/RTPathParse.cpp.h@ 100031

Download in other formats: