nsFileSpecMac.cpp@ 62375

Last change on this file since 62375 was 1, checked in by vboxsync, 55 years ago
import
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 49.1 KB

Line
1	/* -- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -- */
2	/* *** BEGIN LICENSE BLOCK ***
3	* Version: MPL 1.1/GPL 2.0/LGPL 2.1
4	*
5	* The contents of this file are subject to the Mozilla Public License Version
6	* 1.1 (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	* http://www.mozilla.org/MPL/
9	*
10	* Software distributed under the License is distributed on an "AS IS" basis,
11	* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12	* for the specific language governing rights and limitations under the
13	* License.
14	*
15	* The Original Code is mozilla.org code.
16	*
17	* The Initial Developer of the Original Code is
18	* Netscape Communications Corporation.
19	* Portions created by the Initial Developer are Copyright (C) 1998
20	* the Initial Developer. All Rights Reserved.
21	*
22	* Contributor(s):
23	*
24	* Alternatively, the contents of this file may be used under the terms of
25	* either of the GNU General Public License Version 2 or later (the "GPL"),
26	* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
27	* in which case the provisions of the GPL or the LGPL are applicable instead
28	* of those above. If you wish to allow use of your version of this file only
29	* under the terms of either the GPL or the LGPL, and not to allow others to
30	* use your version of this file under the terms of the MPL, indicate your
31	* decision by deleting the provisions above and replace them with the notice
32	* and other provisions required by the GPL or the LGPL. If you do not delete
33	* the provisions above, a recipient may use your version of this file under
34	* the terms of any one of the MPL, the GPL or the LGPL.
35	*
36	* *** END LICENSE BLOCK *** */
37
38	// This file is included by nsFile.cp, and includes the Macintosh-specific
39	// implementations.
40
41
42	#include <string.h>
43
44	#include "prtypes.h"
45	#include "nscore.h"
46
47	#include "FullPath.h"
48	#include "FileCopy.h"
49	#include "MoreFilesExtras.h"
50
51	#include <Aliases.h>
52	#include <Folders.h>
53	#include <Math64.h>
54	#include <TextUtils.h>
55	#include <Processes.h>
56	#include <limits.h> // ULONG_MAX
57
58	#include "nsFileSpec.h"
59	#include "nsEscape.h"
60	#include "nsXPIDLString.h"
61
62
63	const unsigned char* kAliasHavenFolderName = "\pnsAliasHaven";
64
65	//========================================================================================
66	namespace MacFileHelpers
67	//========================================================================================
68	{
69	inline void PLstrcpy(Str255 dst, ConstStr255Param src)
70	{
71	memcpy(dst, src, 1 + src[0]);
72	}
73
74	void PLstrcpy(Str255 dst, const char* src, int inMaxLen=255);
75	void PLstrncpy(Str255 dst, const char* src, int inMaxLen);
76
77	void SwapSlashColon(char * s);
78	OSErr FSSpecFromUnixPath(
79	const char * unixPath,
80	FSSpec& ioSpec,
81	Boolean hexDecode,
82	Boolean resolveAlias,
83	Boolean allowPartial = false,
84	Boolean createDirs = false);
85	char* MacPathFromUnixPath(
86	const char* unixPath,
87	Boolean hexDecode);
88	char* EncodeMacPath(
89	char* inPath, // NOT const - gets clobbered
90	Boolean prependSlash,
91	Boolean doEscape );
92	OSErr FSSpecFromPathname(
93	const char* inPathNamePtr,
94	FSSpec& ioSpec,
95	Boolean inCreateDirs);
96	char* PathNameFromFSSpec(
97	const FSSpec& inSpec );
98	OSErr CreateFolderInFolder(
99	short refNum, // Parent directory/volume
100	long dirID,
101	ConstStr255Param folderName, // Name of the new folder
102	short& outRefNum, // Volume of the created folder
103	long& outDirID); //
104
105	// Some routines to support an "alias haven" directory. Aliases in this directory
106	// are never resolved. There is a ResolveAlias here that respects that. This is
107	// to support attaching of aliases in mail.
108	void EnsureAliasHaven();
109	void SetNoResolve(Boolean inResolve);
110	PRBool IsAliasSafe(const FSSpec& inSpec);
111	OSErr MakeAliasSafe(FSSpec& inOutSpec);
112	OSErr ResolveAliasFile(FSSpec& inOutSpec, Boolean& wasAliased);
113
114	Boolean sNoResolve = false;
115	long sAliasHavenDirID = 0;
116	short sAliasHavenVRefNum = 0;
117	} // namespace MacFileHelpers
118
119	//----------------------------------------------------------------------------------------
120	void MacFileHelpers::PLstrcpy(Str255 dst, const char* src, int inMax)
121	//----------------------------------------------------------------------------------------
122	{
123	int srcLength = strlen(src);
124	NS_ASSERTION(srcLength <= inMax, "Oops, string is too long!");
125	if (srcLength > inMax)
126	srcLength = inMax;
127	dst[0] = srcLength;
128	memcpy(&dst[1], src, srcLength);
129	}
130
131	//----------------------------------------------------------------------------------------
132	void MacFileHelpers::PLstrncpy(Str255 dst, const char* src, int inMax)
133	//----------------------------------------------------------------------------------------
134	{
135	int srcLength = strlen(src);
136	if (srcLength > inMax)
137	srcLength = inMax;
138	dst[0] = srcLength;
139	memcpy(&dst[1], src, srcLength);
140	}
141
142	//-----------------------------------
143	void MacFileHelpers::SwapSlashColon(char * s)
144	//-----------------------------------
145
146	{
147	while (*s)
148	{
149	if (*s == '/')
150	*s++ = ':';
151	else if (*s == ':')
152	*s++ = '/';
153	else
154	*s++;
155	}
156	} // MacFileHelpers::SwapSlashColon
157
158	//-----------------------------------
159	char* MacFileHelpers::EncodeMacPath(
160	char* inPath, // NOT const, gets clobbered
161	Boolean prependSlash,
162	Boolean doEscape )
163	// Transforms Macintosh style path into Unix one
164	// Method: Swap ':' and '/', hex escape the result
165	//-----------------------------------
166	{
167	if (inPath == nsnull)
168	return nsnull;
169	int pathSize = strlen(inPath);
170
171	// XP code sometimes chokes if there's a final slash in the unix path.
172	// Since correct mac paths to folders and volumes will end in ':', strip this
173	// first.
174	char* c = inPath + pathSize - 1;
175	if (*c == ':')
176	{
177	*c = 0;
178	pathSize--;
179	}
180
181	char * newPath = nsnull;
182	char * finalPath = nsnull;
183
184	if (prependSlash)
185	{
186	newPath = new char[pathSize + 2];
187	newPath[0] = ':'; // It will be converted to '/'
188	memcpy(&newPath[1], inPath, pathSize + 1);
189	}
190	else
191	{
192	newPath = new char[pathSize + 1];
193	strcpy(newPath, inPath);
194	}
195	if (newPath)
196	{
197	SwapSlashColon( newPath );
198	if (doEscape)
199	{
200	finalPath = nsEscape(newPath, url_Path);
201	delete [] newPath;
202	}
203	else
204	finalPath = newPath;
205	}
206	delete [] inPath;
207	return finalPath;
208	} // MacFileHelpers::EncodeMacPath
209
210	//----------------------------------------------------------------------------------------
211	inline void MacFileHelpers::SetNoResolve(Boolean inResolve)
212	//----------------------------------------------------------------------------------------
213	{
214	sNoResolve = inResolve;
215	} // MacFileHelpers::SetNoResolve
216
217	//----------------------------------------------------------------------------------------
218	OSErr MacFileHelpers::MakeAliasSafe(FSSpec& inOutSpec)
219	// Pass in the spec of an alias. This copies the file to the safe haven folder, and
220	// returns the spec of the copy to the caller
221	//----------------------------------------------------------------------------------------
222	{
223	EnsureAliasHaven();
224	nsFileSpec dstDirSpec(sAliasHavenVRefNum, sAliasHavenDirID, "\p");
225
226	// Make sure its name is unique
227	nsFileSpec havenSpec(sAliasHavenVRefNum, sAliasHavenDirID, "\pG'day");
228	if (havenSpec.Valid())
229	havenSpec.MakeUnique(inOutSpec.name);
230	// Copy the file into the haven directory
231	if (havenSpec.Valid())
232	{
233	OSErr err = ::FSpFileCopy(
234	&inOutSpec,
235	dstDirSpec,
236	havenSpec.GetLeafPName(),
237	nil, 0, true);
238	// Return the spec of the copy to the caller.
239	if (err != noErr)
240	return err;
241	inOutSpec = havenSpec;
242	}
243	return noErr;
244	} // MacFileHelpers::MakeAliasSafe
245
246	//----------------------------------------------------------------------------------------
247	char* MacFileHelpers::MacPathFromUnixPath(const char* unixPath, Boolean hexDecode)
248	//----------------------------------------------------------------------------------------
249	{
250	// Relying on the fact that the unix path is always longer than the mac path:
251	size_t len = strlen(unixPath);
252	char* result = new char[len + 2]; // ... but allow for the initial colon in a partial name
253	// REMEMBER: at the end we call SwapSlashColon, so bear that in mind when you see
254	// this code using '/' as a separator in what is supposed to be a Macintosh path!
255	if (result)
256	{
257	char* dst = result;
258	const char* src = unixPath;
259	if (src == '/') // full path
260	src++;
261	else if (strchr(src, '/') && *src != '.')
262	{
263	// * partial path, and not just a leaf name. The '.' test is there because
264	// the loop below will add sufficient colons in that case.
265	*dst++ = '/';
266	}
267	// Copy src to dst, but watch out for .. and .
268	char c = '/';
269	do
270	{
271	char cprev = c; // remember the previous char (initially /)
272	c = *src++;
273	if (c == '.' && cprev == '/')
274	{
275	char* dstSaved = dst;
276	// Special cases: "." and "..". Convert to ':' and '::'
277	*dst++ = '/'; // . becomes :
278	c = *src++;
279	if (c == '.')
280	{
281	*dst++ = '/'; // .. becomes ::
282	c = *src++;
283	}
284	if (c == '/')
285	{
286	// ../ becomes :: so just skip the slash
287	// ./ becomes : " " " " "
288	src++;
289	}
290	else if (c)
291	{
292	// Oh. A file called ".foo" or "..foo"
293	// Back up and just do the normal thing.
294	src -= (dst - dstSaved);
295	dst = dstSaved;
296	// Since c is not '/', we won't do this stuff on the
297	// next iteration.
298	}
299	continue;
300	}
301	else if (c == '/' && cprev == '/')
302	{
303	// Hmm. A 'run on' path with two slashes right next to each other.
304	// This is an illegal path, but, hey, we'll be tough and try to
305	// deal with it (especially since '::' has loaded semantics in
306	// a Mac path)
307	continue;
308	}
309	*dst++ = c;
310	} while (c);
311	if (hexDecode)
312	nsUnescape(result); // Hex Decode
313	MacFileHelpers::SwapSlashColon(result);
314	}
315	return result;
316	} // MacFileHelpers::MacPathFromUnixPath
317
318	//----------------------------------------------------------------------------------------
319	OSErr MacFileHelpers::FSSpecFromPathname(
320	const char* inPathNamePtr,
321	FSSpec& ioSpec, // used as in-parameter for a relative path.
322	Boolean inCreateDirs)
323	// FSSpecFromPathname reverses PathNameFromFSSpec.
324	// It returns a FSSpec given a c string which is a mac pathname.
325	//----------------------------------------------------------------------------------------
326	{
327	OSErr err;
328	// Simplify this routine to use FSMakeFSSpec if length < 255. Otherwise use the MoreFiles
329	// routine FSpLocationFromFullPath, which allocates memory, to handle longer pathnames.
330
331	short inVRefNum = ioSpec.vRefNum;
332	long inParID = ioSpec.parID;
333
334	size_t inLength = strlen(inPathNamePtr);
335	bool isRelative = (strchr(inPathNamePtr, ':') == 0 \|\| *inPathNamePtr == ':');
336	#ifdef NS_DEBUG
337	// Attempt to catch people sending unix paths in to routines that expect native ones.
338	NS_ASSERTION(strchr(inPathNamePtr, '/') == 0,
339	"Possible unix path where native path is required");
340	#endif
341	if (inLength < 255)
342	{
343	Str255 pascalpath;
344	MacFileHelpers::PLstrcpy(pascalpath, inPathNamePtr);
345	if (isRelative)
346	err = ::FSMakeFSSpec(inVRefNum, inParID, pascalpath, &ioSpec);
347	else
348	err = ::FSMakeFSSpec(0, 0, pascalpath, &ioSpec);
349	}
350	else if (!isRelative)
351	err = FSpLocationFromFullPath(inLength, inPathNamePtr, &ioSpec);
352	else
353	err = bdNamErr;
354
355	if ((err == dirNFErr \|\| err == bdNamErr) && inCreateDirs)
356	{
357	const char* path = inPathNamePtr;
358	if (isRelative)
359	{
360	ioSpec.vRefNum = inVRefNum;
361	ioSpec.parID = inParID;
362	}
363	else
364	{
365	ioSpec.vRefNum = 0;
366	ioSpec.parID = 0;
367	}
368	do {
369	// Locate the colon that terminates the node.
370	// But if we've a partial path (starting with a colon), find the second one.
371	const char* nextColon = strchr(path + (*path == ':'), ':');
372	// Well, if there are no more colons, point to the end of the string.
373	if (!nextColon)
374	nextColon = path + strlen(path);
375
376	// Make a pascal string out of this node. Include initial
377	// and final colon, if any!
378	Str255 ppath;
379	MacFileHelpers::PLstrncpy(ppath, path, nextColon - path + 1);
380
381	// Use this string as a relative path using the directory created
382	// on the previous round (or directory 0,0 on the first round).
383	err = ::FSMakeFSSpec(ioSpec.vRefNum, ioSpec.parID, ppath, &ioSpec);
384
385	// If this was the leaf node, then we are done.
386	if (!*nextColon)
387	break;
388
389	// Since there's more to go, we have to get the directory ID, which becomes
390	// the parID for the next round.
391	if (err == noErr)
392	{
393	// The directory (or perhaps a file) exists. Find its dirID.
394	long dirID;
395	Boolean isDirectory;
396	err = ::FSpGetDirectoryID(&ioSpec, &dirID, &isDirectory);
397	if (!isDirectory)
398	return dupFNErr; // oops! a file exists with that name.
399	if (err)
400	return err;
401	ioSpec.parID = dirID;
402	}
403	else if (err == fnfErr)
404	{
405	// If we got "file not found", then
406	// we need to create a directory.
407	err = ::FSpDirCreate(&ioSpec, smCurrentScript, &ioSpec.parID);
408	// For some reason, this usually returns fnfErr, even though it works.
409	if (err == fnfErr)
410	err = noErr;
411	}
412	if (err != noErr)
413	return err;
414	path = nextColon; // next round
415	} while (1);
416	}
417	return err;
418	} // MacFileHelpers::FSSpecFromPathname
419
420	//----------------------------------------------------------------------------------------
421	OSErr MacFileHelpers::CreateFolderInFolder(
422	short refNum, // Parent directory/volume
423	long dirID,
424	ConstStr255Param folderName, // Name of the new folder
425	short& outRefNum, // Volume of the created folder
426	long& outDirID) //
427	// Creates a folder named 'folderName' inside a folder.
428	// The errors returned are same as PBDirCreate
429	//----------------------------------------------------------------------------------------
430	{
431	HFileParam hpb;
432	hpb.ioVRefNum = refNum;
433	hpb.ioDirID = dirID;
434	hpb.ioNamePtr = (StringPtr)&folderName;
435
436	OSErr err = PBDirCreateSync((HParmBlkPtr)&hpb);
437	if (err == noErr)
438	{
439	outRefNum = hpb.ioVRefNum;
440	outDirID = hpb.ioDirID;
441	}
442	else
443	{
444	outRefNum = 0;
445	outDirID = 0;
446	}
447	return err;
448	} // MacFileHelpers::CreateFolderInFolder
449
450	//----------------------------------------------------------------------------------------
451	void MacFileHelpers::EnsureAliasHaven()
452	//----------------------------------------------------------------------------------------
453	{
454	// Alias Haven is a directory in which we never resolve aliases.
455	if (sAliasHavenVRefNum != 0)
456	return;
457
458
459	FSSpec temp;
460	if (FindFolder(0, kTemporaryFolderType, true, & temp.vRefNum, &temp.parID) == noErr)
461	{
462	CreateFolderInFolder(
463	temp.vRefNum, // Parent directory/volume
464	temp.parID,
465	kAliasHavenFolderName, // Name of the new folder
466	sAliasHavenVRefNum, // Volume of the created folder
467	sAliasHavenDirID);
468	}
469	} // MacFileHelpers::EnsureAliasHaven
470
471	//----------------------------------------------------------------------------------------
472	PRBool MacFileHelpers::IsAliasSafe(const FSSpec& inSpec)
473	// Returns true if the alias is in the alias haven directory, or if alias resolution
474	// has been turned off.
475	//----------------------------------------------------------------------------------------
476	{
477	return sNoResolve
478	\|\| (inSpec.parID == sAliasHavenDirID && inSpec.vRefNum == sAliasHavenVRefNum);
479	} // MacFileHelpers::IsAliasSafe
480
481	//----------------------------------------------------------------------------------------
482	OSErr MacFileHelpers::ResolveAliasFile(FSSpec& inOutSpec, Boolean& wasAliased)
483	//----------------------------------------------------------------------------------------
484	{
485	wasAliased = false;
486	if (IsAliasSafe(inOutSpec))
487	return noErr;
488	Boolean dummy;
489	return ::ResolveAliasFile(&inOutSpec, TRUE, &dummy, &wasAliased);
490	} // MacFileHelpers::ResolveAliasFile
491
492	//-----------------------------------
493	OSErr MacFileHelpers::FSSpecFromUnixPath(
494	const char * unixPath,
495	FSSpec& ioSpec,
496	Boolean hexDecode,
497	Boolean resolveAlias,
498	Boolean allowPartial,
499	Boolean createDirs)
500	// File spec from URL. Reverses GetURLFromFileSpec
501	// Its input is only the <path> part of the URL
502	// JRM 97/01/08 changed this so that if it's a partial path (doesn't start with '/'),
503	// then it is combined with inOutSpec's vRefNum and parID to form a new spec.
504	//-----------------------------------
505	{
506	if (unixPath == nsnull)
507	return badFidErr;
508	char* macPath = MacPathFromUnixPath(unixPath, hexDecode);
509	if (!macPath)
510	return memFullErr;
511
512	OSErr err = noErr;
513	if (!allowPartial)
514	{
515	NS_ASSERTION(unixPath == '/' /full path*/, "Not a full Unix path!");
516	}
517	err = FSSpecFromPathname(macPath, ioSpec, createDirs);
518	if (err == fnfErr)
519	err = noErr;
520	Boolean dummy;
521	if (err == noErr && resolveAlias) // Added
522	err = MacFileHelpers::ResolveAliasFile(ioSpec, dummy);
523	delete [] macPath;
524	NS_ASSERTION(err==noErr\|\|err==fnfErr\|\|err==dirNFErr\|\|err==nsvErr, "Not a path!");
525	return err;
526	} // MacFileHelpers::FSSpecFromLocalUnixPath
527
528	//-----------------------------------
529	char* MacFileHelpers::PathNameFromFSSpec( const FSSpec& inSpec )
530	// Returns a full pathname to the given file
531	// Returned value is allocated with new [], and must be freed with delete []
532	// For consistency and to work under OS X this creates an nsILocalFileMac and has it do the work.
533	//-----------------------------------
534	{
535	char* result = nil;
536	nsresult rv;
537
538	FSSpec nonConstSpec = inSpec;
539	nsCAutoString path;
540	nsCOMPtr<nsILocalFileMac> macFile;
541
542	rv = NS_NewLocalFileWithFSSpec(&nonConstSpec, PR_TRUE, getter_AddRefs(macFile));
543	if (NS_FAILED(rv)) return nsnull;
544	nsCOMPtr<nsILocalFile> localFile(do_QueryInterface(macFile, &rv));
545	if (NS_FAILED(rv)) return nsnull;
546	rv = localFile->GetNativePath(path);
547	if (NS_FAILED(rv)) return nsnull;
548	PRInt32 strLen = path.Length();
549	result = new char [strLen + 1];
550	if (!result) return nsnull;
551	memcpy(result, path.get(), strLen);
552	result[ strLen ] = 0;
553
554	return result;
555	} // MacFileHelpers::PathNameFromFSSpec
556
557
558	#pragma mark -
559
560	//========================================================================================
561	// Macintosh nsFileSpec implementation
562	//========================================================================================
563
564	//----------------------------------------------------------------------------------------
565	nsFileSpec::nsFileSpec()
566	//----------------------------------------------------------------------------------------
567	{
568	// NS_ASSERTION(0, "nsFileSpec is unsupported - use nsIFile!");
569	Clear();
570	}
571
572	//----------------------------------------------------------------------------------------
573	nsFileSpec::nsFileSpec(const FSSpec& inSpec, PRBool resolveAlias)
574	//----------------------------------------------------------------------------------------
575	: mSpec(inSpec)
576	, mError(NS_OK)
577	{
578	// NS_ASSERTION(0, "nsFileSpec is unsupported - use nsIFile!");
579	if (resolveAlias)
580	{
581	PRBool dummy;
582	ResolveSymlink(dummy);
583	}
584	}
585
586	//----------------------------------------------------------------------------------------
587	void nsFileSpec::operator = (const FSSpec& inSpec)
588	//----------------------------------------------------------------------------------------
589	{
590	mSpec = inSpec;
591	mError = NS_OK;
592	}
593
594	//----------------------------------------------------------------------------------------
595	nsFileSpec::nsFileSpec(const nsFileSpec& inSpec)
596	//----------------------------------------------------------------------------------------
597	: mSpec(inSpec.mSpec)
598	, mError(inSpec.Error())
599	{
600	// NS_ASSERTION(0, "nsFileSpec is unsupported - use nsIFile!");
601	}
602
603	//----------------------------------------------------------------------------------------
604	nsFileSpec::nsFileSpec(const char* inNativePathString, PRBool inCreateDirs)
605	//----------------------------------------------------------------------------------------
606	{
607	// NS_ASSERTION(0, "nsFileSpec is unsupported - use nsIFile!");
608	Clear(); // this sets mError to NS_ERROR_NOT_INITIALIZED
609
610	if (inNativePathString)
611	{
612	mError = NS_FILE_RESULT(MacFileHelpers::FSSpecFromPathname(
613	inNativePathString, mSpec, inCreateDirs));
614	if (mError == NS_FILE_RESULT(fnfErr))
615	mError = NS_OK;
616	}
617
618	} // nsFileSpec::nsFileSpec
619
620	//----------------------------------------------------------------------------------------
621	nsFileSpec::nsFileSpec(const nsString& inNativePathString, PRBool inCreateDirs)
622	//----------------------------------------------------------------------------------------
623	{
624	// NS_ASSERTION(0, "nsFileSpec is unsupported - use nsIFile!");
625	Clear(); // this sets mError to NS_ERROR_NOT_INITIALIZED
626
627	mError = NS_FILE_RESULT(
628	MacFileHelpers::FSSpecFromPathname(
629	NS_LossyConvertUCS2toASCII(inNativePathString).get(),
630	mSpec, inCreateDirs));
631	if (mError == NS_FILE_RESULT(fnfErr))
632	mError = NS_OK;
633
634	} // nsFileSpec::nsFileSpec
635
636	//----------------------------------------------------------------------------------------
637	nsFileSpec::nsFileSpec(short vRefNum, long parID, ConstStr255Param fileName, PRBool resolveAlias)
638	//----------------------------------------------------------------------------------------
639	{
640	// NS_ASSERTION(0, "nsFileSpec is unsupported - use nsIFile!");
641	mError = NS_FILE_RESULT(::FSMakeFSSpec(vRefNum, parID, fileName, &mSpec));
642	if (mError == NS_FILE_RESULT(fnfErr))
643	mError = NS_OK;
644
645	if (resolveAlias)
646	{
647	PRBool dummy;
648	ResolveSymlink(dummy);
649	}
650	}
651
652	//----------------------------------------------------------------------------------------
653	nsFileSpec::nsFileSpec(const nsFilePath& inPath)
654	//----------------------------------------------------------------------------------------
655	{
656	// NS_ASSERTION(0, "nsFileSpec is unsupported - use nsIFile!");
657	*this = inPath.GetFileSpec();
658	}
659
660	//----------------------------------------------------------------------------------------
661	void nsFileSpec::operator = (const char* inString)
662	//----------------------------------------------------------------------------------------
663	{
664	Clear(); // this sets mError to NS_ERROR_NOT_INITIALIZED
665
666	if (inString)
667	{
668	mError = NS_FILE_RESULT(MacFileHelpers::FSSpecFromPathname(inString, mSpec, true));
669	if (mError == NS_FILE_RESULT(fnfErr))
670	mError = NS_OK;
671	}
672
673	} // nsFileSpec::operator =
674
675	//----------------------------------------------------------------------------------------
676	void nsFileSpec::operator = (const nsFileSpec& inSpec)
677	//----------------------------------------------------------------------------------------
678	{
679	mPath.SetToEmpty();
680	mSpec.vRefNum = inSpec.mSpec.vRefNum;
681	mSpec.parID = inSpec.mSpec.parID;
682
683	PRInt32 copySize = inSpec.mSpec.name[0] + 1;
684	if (copySize > sizeof(inSpec.mSpec.name))
685	copySize = sizeof(inSpec.mSpec.name);
686	memcpy(mSpec.name, inSpec.mSpec.name, copySize);
687	mError = inSpec.Error(); // note that the error is propagated
688	} // nsFileSpec::operator =
689
690	//----------------------------------------------------------------------------------------
691	void nsFileSpec::operator = (const nsFilePath& inPath)
692	//----------------------------------------------------------------------------------------
693	{
694	*this = inPath.GetFileSpec();
695	} // nsFileSpec::operator =
696
697	//----------------------------------------------------------------------------------------
698	inline void nsFileSpec::Clear()
699	//----------------------------------------------------------------------------------------
700	{
701	mPath.SetToEmpty();
702	mSpec.vRefNum = 0;
703	mSpec.parID = 0;
704	mSpec.name[0] = 0;
705	mError = NS_ERROR_NOT_INITIALIZED;
706	}
707
708	//----------------------------------------------------------------------------------------
709	PRBool nsFileSpec::Exists() const
710	//----------------------------------------------------------------------------------------
711	{
712	if (NS_FAILED(mError)) return PR_FALSE;
713	FSSpec temp;
714	return ::FSMakeFSSpec(mSpec.vRefNum, mSpec.parID, mSpec.name, &temp) == noErr;
715	} // nsFileSpec::Exists()
716
717	//----------------------------------------------------------------------------------------
718	void nsFileSpec::GetModDate(TimeStamp& outStamp) const
719	//----------------------------------------------------------------------------------------
720	{
721	CInfoPBRec pb;
722	if (GetCatInfo(pb) == noErr)
723	outStamp = ((DirInfo*)&pb)->ioDrMdDat; // The mod date is in the same spot for files and dirs.
724	else
725	outStamp = 0;
726	} // nsFileSpec::GetModDate
727
728	//----------------------------------------------------------------------------------------
729	PRUint32 nsFileSpec::GetFileSize() const
730	//----------------------------------------------------------------------------------------
731	{
732	CInfoPBRec pb;
733	if (noErr == GetCatInfo(pb))
734	return (PRUint32)((HFileInfo*)&pb)->ioFlLgLen;
735	return 0;
736	} // nsFileSpec::GetFileSize
737
738	//----------------------------------------------------------------------------------------
739	void nsFileSpec::SetLeafName(const char* inLeafName)
740	// In leaf name can actually be a partial path...
741	//----------------------------------------------------------------------------------------
742	{
743	NS_ASSERTION(inLeafName, "Attempt to set leaf name with a null string");
744
745	mPath.SetToEmpty();
746
747	if (inLeafName)
748	{
749	// what about long relative paths? Hmm? We don't have a routine for this anywhere.
750	Str255 partialPath;
751	MacFileHelpers::PLstrcpy(partialPath, inLeafName);
752	mError = NS_FILE_RESULT(
753	::FSMakeFSSpec(mSpec.vRefNum, mSpec.parID, partialPath, &mSpec));
754	if (mError == NS_FILE_RESULT(fnfErr))
755	mError = NS_OK;
756	}
757
758	} // nsFileSpec::SetLeafName
759
760	//----------------------------------------------------------------------------------------
761	char* nsFileSpec::GetLeafName() const
762	// Result needs to be nsCRT::free()ed.
763	//----------------------------------------------------------------------------------------
764	{
765	char leaf[sizeof(mSpec.name)];
766	memcpy(leaf, &mSpec.name[1], mSpec.name[0]);
767	leaf[mSpec.name[0]] = '\0';
768	return nsCRT::strdup(leaf);
769	} // nsFileSpec::GetLeafName
770
771	//----------------------------------------------------------------------------------------
772	void nsFileSpec::MakeAliasSafe()
773	//----------------------------------------------------------------------------------------
774	{
775	mPath.SetToEmpty();
776	mError = NS_FILE_RESULT(MacFileHelpers::MakeAliasSafe(mSpec));
777	} // nsFileSpec::MakeAliasSafe
778
779	//----------------------------------------------------------------------------------------
780	void nsFileSpec::MakeUnique(ConstStr255Param inSuggestedLeafName)
781	//----------------------------------------------------------------------------------------
782	{
783	mPath.SetToEmpty();
784	if (inSuggestedLeafName[0] > 0)
785	MacFileHelpers::PLstrcpy(mSpec.name, inSuggestedLeafName);
786
787	MakeUnique();
788	} // nsFileSpec::MakeUnique
789
790	//----------------------------------------------------------------------------------------
791	PRBool nsFileSpec::IsFile() const
792	//----------------------------------------------------------------------------------------
793	{
794	long dirID;
795	Boolean isDirectory;
796	return (noErr == ::FSpGetDirectoryID(&mSpec, &dirID, &isDirectory) && !isDirectory);
797	} // nsFileSpec::IsFile
798
799	//----------------------------------------------------------------------------------------
800	PRBool nsFileSpec::IsDirectory() const
801	//----------------------------------------------------------------------------------------
802	{
803	long dirID;
804	Boolean isDirectory;
805	return (noErr == ::FSpGetDirectoryID(&mSpec, &dirID, &isDirectory) && isDirectory);
806	} // nsFileSpec::IsDirectory
807
808	//----------------------------------------------------------------------------------------
809	PRBool nsFileSpec::IsHidden() const
810	//----------------------------------------------------------------------------------------
811	{
812	CInfoPBRec cInfo;
813	PRBool hidden = PR_FALSE;
814
815	if (noErr == GetCatInfo(cInfo))
816	if (cInfo.hFileInfo.ioFlFndrInfo.fdFlags & kIsInvisible)
817	hidden = PR_TRUE;
818
819	return hidden;
820	} // nsFileSpec::IsHidden
821
822	//----------------------------------------------------------------------------------------
823	PRBool nsFileSpec::IsSymlink() const
824	//----------------------------------------------------------------------------------------
825	{
826	CInfoPBRec cInfo;
827	PRBool hidden = PR_FALSE;
828
829	if (noErr == GetCatInfo(cInfo))
830	if (cInfo.hFileInfo.ioFlFndrInfo.fdFlags & kIsAlias)
831	hidden = PR_TRUE;
832
833	return hidden;
834	} // nsFileSpec::IsSymlink
835
836	//----------------------------------------------------------------------------------------
837	nsresult nsFileSpec::ResolveSymlink(PRBool& wasAliased)
838	//----------------------------------------------------------------------------------------
839	{
840	Boolean wasAliased2; // Type conversion Boolean <--> PRBool
841	OSErr err = MacFileHelpers::ResolveAliasFile(mSpec, wasAliased2);
842	if (wasAliased2)
843	{
844	mError = NS_FILE_RESULT(err);
845	wasAliased = PR_TRUE;
846	}
847	else
848	wasAliased = PR_FALSE;
849
850	return mError;
851	} // nsFileSpec::ResolveSymlink
852
853	//----------------------------------------------------------------------------------------
854	void nsFileSpec::GetParent(nsFileSpec& outSpec) const
855	//----------------------------------------------------------------------------------------
856	{
857	if (NS_SUCCEEDED(mError))
858	outSpec.mError = NS_FILE_RESULT(::FSMakeFSSpec(mSpec.vRefNum, mSpec.parID, nsnull, outSpec));
859	} // nsFileSpec::GetParent
860
861	//----------------------------------------------------------------------------------------
862	void nsFileSpec::operator += (const char* inRelativePath)
863	//----------------------------------------------------------------------------------------
864	{
865	NS_ASSERTION(inRelativePath, "Attempt to append relative path with null path");
866
867	// Invalidate the path cache string, since we're changing ourselves.
868	mPath.SetToEmpty();
869
870	// if we are already bad, don't allow appendage
871	if (NS_FAILED(Error()))
872	{
873	NS_WARNING("trying to append to a bad nsFileSpec");
874	return;
875	}
876
877	// Find the dirID of the directory described by this spec
878	long dirID;
879	Boolean isDirectory;
880	mError = NS_FILE_RESULT(::FSpGetDirectoryID(&mSpec, &dirID, &isDirectory));
881	if (NS_FAILED(mError) \|\| !isDirectory \|\| !inRelativePath)
882	return;
883	// mSpec.vRefNum is already correct.
884	mSpec.parID = dirID;
885
886	// Next, determine if it is a UNIX or Mac style path. Now, Macintosh relative paths
887	// are either leaf names (in which the distinction between unix and macintosh
888	// relative paths disappears) or they start with a colon. If we find an initial colon,
889	// then assume it's a macintosh path.
890	// If it is a UNIX path (including just a leaf name), we will also look for ':' and
891	// assert if we find one.
892	if (*inRelativePath != ':')
893	{
894	// Looks like a UNIX path (including possibly just a leaf name)
895	NS_ASSERTION(strchr(inRelativePath, ':') == nsnull, "Can not determine path type");
896	// Convert unix path (which is unencoded) to a spec
897	mError = NS_FILE_RESULT(
898	MacFileHelpers::FSSpecFromUnixPath(inRelativePath, mSpec, false, false, true, true));
899	}
900	else
901	{
902	// We must be a mac path!
903	mError = NS_FILE_RESULT(MacFileHelpers::FSSpecFromPathname(inRelativePath, mSpec, true));
904	}
905	if (mError == NS_FILE_RESULT(fnfErr))
906	mError = NS_OK;
907
908	} // nsFileSpec::operator +=
909
910	//----------------------------------------------------------------------------------------
911	void nsFileSpec::CreateDirectory(int /* unix mode */)
912	//----------------------------------------------------------------------------------------
913	{
914	long ignoredDirID;
915	OSErr err = ::FSpDirCreate(&mSpec, smCurrentScript, &ignoredDirID);
916	// it's OK if the dir already exists
917	if (err != noErr && IsDirectory())
918	err = noErr;
919
920	mError = NS_FILE_RESULT(err);
921
922	} // nsFileSpec::CreateDirectory
923
924	//----------------------------------------------------------------------------------------
925	void nsFileSpec::Delete(PRBool inRecursive) const
926	//----------------------------------------------------------------------------------------
927	{
928	OSErr anErr;
929
930	nsresult& mutableError = const_cast<nsFileSpec*>(this)->mError;
931	if (inRecursive)
932	{
933	// MoreFilesExtras
934	anErr = ::DeleteDirectory(
935	mSpec.vRefNum,
936	mSpec.parID,
937	const_cast<unsigned char*>(mSpec.name));
938	}
939	else
940	anErr = ::FSpDelete(&mSpec);
941
942	if (anErr == fnfErr) // deleting a file that doesn't exist isn't an error!
943	anErr = noErr;
944
945	mutableError = NS_FILE_RESULT(anErr);
946
947	} // nsFileSpec::Delete
948
949	//----------------------------------------------------------------------------------------
950	void nsFileSpec::RecursiveCopy(nsFileSpec newDir) const
951	//----------------------------------------------------------------------------------------
952	{
953	if (IsDirectory())
954	{
955	if (!(newDir.Exists()))
956	{
957	newDir.CreateDirectory();
958	}
959
960	for (nsDirectoryIterator i(*this, PR_FALSE); i.Exists(); i++)
961	{
962	nsFileSpec& child = (nsFileSpec&)i;
963
964	if (child.IsDirectory())
965	{
966	nsFileSpec tmpDirSpec(newDir);
967
968	char *leafname = child.GetLeafName();
969	tmpDirSpec += leafname;
970	nsCRT::free(leafname);
971
972	child.RecursiveCopy(tmpDirSpec);
973	}
974	else
975	{
976	child.RecursiveCopy(newDir);
977	}
978	}
979	}
980	else
981	{
982	nsFileSpec& filePath = (nsFileSpec&) *this;
983
984	if (!(newDir.Exists()))
985	{
986	newDir.CreateDirectory();
987	}
988
989	filePath.CopyToDir(newDir);
990	}
991	} // nsFileSpec::RecursiveCopy
992
993	//----------------------------------------------------------------------------------------
994	nsresult nsFileSpec::Truncate(PRInt32 aNewLength) const
995	//----------------------------------------------------------------------------------------
996	{
997	short refNum;
998	OSErr err;
999
1000	// First see if we have an internal error set
1001	if (NS_FAILED(mError))
1002	return mError;
1003
1004	// Need to open the file to trunc
1005	if (::FSpOpenDF(&mSpec, fsWrPerm, &refNum) != noErr)
1006	return NS_FILE_FAILURE;
1007
1008	err = ::SetEOF(refNum, aNewLength);
1009
1010	// Close the file unless we got an error that it was already closed
1011	if (err != fnOpnErr)
1012	(void)::FSClose(refNum);
1013
1014	if (err != noErr)
1015	return NS_FILE_FAILURE;
1016
1017	return NS_OK;
1018	} // nsFileSpec::Truncate
1019
1020	//----------------------------------------------------------------------------------------
1021	nsresult nsFileSpec::Rename(const char* inNewName)
1022	//----------------------------------------------------------------------------------------
1023	{
1024	NS_ASSERTION(inNewName, "Attempt to rename with null new name");
1025
1026	if (strchr(inNewName, '/'))
1027	return NS_FILE_FAILURE; // no relative paths here!
1028
1029	Str255 pName;
1030	MacFileHelpers::PLstrcpy(pName, inNewName);
1031	if (::FSpRename(&mSpec, pName) != noErr)
1032	return NS_FILE_FAILURE;
1033	SetLeafName(inNewName);
1034	return NS_OK;
1035	} // nsFileSpec::Rename
1036
1037	//----------------------------------------------------------------------------------------
1038	nsresult nsFileSpec::CopyToDir(const nsFileSpec& newParentDir) const
1039	//----------------------------------------------------------------------------------------
1040	{
1041	// We can only copy into a directory, and (for now) can not copy entire directories
1042
1043	if (!newParentDir.IsDirectory() \|\| (IsDirectory() ) )
1044	return NS_FILE_FAILURE;
1045
1046	nsresult rv = NS_FILE_RESULT(::FSpFileCopy(&mSpec,
1047	&newParentDir.mSpec,
1048	const_cast<StringPtr>(GetLeafPName()),
1049	nsnull,
1050	0,
1051	true));
1052
1053	return rv;
1054
1055	} // nsFileSpec::CopyToDir
1056
1057	//----------------------------------------------------------------------------------------
1058	nsresult nsFileSpec::MoveToDir(const nsFileSpec& newParentDir)
1059	//----------------------------------------------------------------------------------------
1060	{
1061	// We can only move into a directory
1062
1063	if (!newParentDir.IsDirectory())
1064	return NS_FILE_FAILURE;
1065
1066	nsresult result = NS_FILE_RESULT(::FSpMoveRenameCompat(&mSpec,
1067	&newParentDir.mSpec,
1068	const_cast<StringPtr>(GetLeafPName())));
1069
1070	if ( NS_SUCCEEDED(result) )
1071	{
1072	char* leafName = GetLeafName();
1073	*this = newParentDir + leafName;
1074	nsCRT::free(leafName);
1075	}
1076	return result;
1077	} // nsFileSpec::MoveToDir
1078
1079	//----------------------------------------------------------------------------------------
1080	nsresult nsFileSpec::Execute(const char* /args - how can this be cross-platform? problem! / ) const
1081	//----------------------------------------------------------------------------------------
1082	{
1083	if (IsDirectory())
1084	return NS_FILE_FAILURE;
1085
1086	LaunchParamBlockRec launchThis;
1087	launchThis.launchAppSpec = const_cast<FSSpec*>(&mSpec);
1088	launchThis.launchAppParameters = nsnull; // args;
1089	/* launch the thing */
1090	launchThis.launchBlockID = extendedBlock;
1091	launchThis.launchEPBLength = extendedBlockLen;
1092	launchThis.launchFileFlags = nsnull;
1093	launchThis.launchControlFlags = launchContinue + launchNoFileFlags + launchUseMinimum;
1094	launchThis.launchControlFlags += launchDontSwitch;
1095
1096	nsresult result = NS_FILE_RESULT(::LaunchApplication(&launchThis));
1097	return result;
1098
1099	} // nsFileSpec::Execute
1100
1101	//----------------------------------------------------------------------------------------
1102	OSErr nsFileSpec::GetCatInfo(CInfoPBRec& outInfo) const
1103	//----------------------------------------------------------------------------------------
1104	{
1105	DirInfo dipb=(DirInfo )&outInfo;
1106	dipb->ioCompletion = nsnull;
1107	dipb->ioFDirIndex = 0; // use dirID and name
1108	dipb->ioVRefNum = mSpec.vRefNum;
1109	dipb->ioDrDirID = mSpec.parID;
1110	dipb->ioNamePtr = const_cast<nsFileSpec*>(this)->mSpec.name;
1111	return PBGetCatInfoSync(&outInfo);
1112	} // nsFileSpec::GetCatInfo()
1113
1114	//----------------------------------------------------------------------------------------
1115	OSErr nsFileSpec::SetFileTypeAndCreator(OSType type, OSType creator)
1116	//----------------------------------------------------------------------------------------
1117	{
1118	FInfo info;
1119	OSErr err = ::FSpGetFInfo(&mSpec, &info);
1120	if (err != noErr)
1121	return err;
1122	info.fdType = type;
1123	info.fdCreator = creator;
1124	err = ::FSpSetFInfo(&mSpec, &info);
1125	return err;
1126	}
1127
1128	//----------------------------------------------------------------------------------------
1129	OSErr nsFileSpec::GetFileTypeAndCreator(OSType* type, OSType* creator)
1130	//----------------------------------------------------------------------------------------
1131	{
1132	FInfo info;
1133	OSErr err = ::FSpGetFInfo(&mSpec, &info);
1134	if (err != noErr)
1135	return err;
1136	*type = info.fdType;
1137	*creator = info.fdCreator;
1138	return noErr;
1139	}
1140
1141	//----------------------------------------------------------------------------------------
1142	PRInt64 nsFileSpec::GetDiskSpaceAvailable() const
1143	//----------------------------------------------------------------------------------------
1144	{
1145	PRInt64 space64Bits;
1146
1147	LL_I2L(space64Bits , LONG_MAX);
1148
1149	XVolumeParam pb;
1150	pb.ioCompletion = nsnull;
1151	pb.ioVolIndex = 0;
1152	pb.ioNamePtr = nsnull;
1153	pb.ioVRefNum = mSpec.vRefNum;
1154
1155	// PBXGetVolInfoSync works on HFS+ volumes too!
1156	OSErr err = ::PBXGetVolInfoSync(&pb);
1157
1158	if (err == noErr)
1159	{
1160	#ifdef HAVE_LONG_LONG
1161	space64Bits = pb.ioVFreeBytes;
1162	#else
1163	const UnsignedWide& freeBytes = UInt64ToUnsignedWide(pb.ioVFreeBytes);
1164	space64Bits.lo = freeBytes.lo;
1165	space64Bits.hi = freeBytes.hi;
1166	#endif
1167	}
1168
1169	return space64Bits;
1170	} // nsFileSpec::GetDiskSpace()
1171
1172	//----------------------------------------------------------------------------------------
1173	const char* nsFileSpec::GetCString() const
1174	// This is the only conversion to const char* that is provided, and it allows the
1175	// path to be "passed" to NSPR file routines. This practice is VERY EVIL and should only
1176	// be used to support legacy code. Using it guarantees bugs on Macintosh. The string is
1177	// cached and freed by the nsFileSpec destructor, so do not delete (or free) it.
1178	//----------------------------------------------------------------------------------------
1179	{
1180	if (mPath.IsEmpty())
1181	{
1182	char* path = MacFileHelpers::PathNameFromFSSpec(mSpec);
1183	if (path != NULL) {
1184	const_cast<nsFileSpec*>(this)->mPath = path; // operator =() copies the string!!!
1185	delete[] path;
1186	} else {
1187	const_cast<nsFileSpec*>(this)->mError = NS_ERROR_OUT_OF_MEMORY;
1188	}
1189	}
1190	return mPath;
1191	}
1192
1193	#pragma mark -
1194
1195	//========================================================================================
1196	// Macintosh nsFilePath implementation
1197	//========================================================================================
1198
1199	//----------------------------------------------------------------------------------------
1200	static void AssignFromPath(nsFilePath& ioPath, const char* inString, PRBool inCreateDirs)
1201	//----------------------------------------------------------------------------------------
1202	{
1203	NS_ASSERTION(inString, "AssignFromPath called with null inString");
1204	NS_ASSERTION(strstr(inString, kFileURLPrefix) != inString, "URL passed as path");
1205
1206	FSSpec spec;
1207	spec.vRefNum = 0;
1208	spec.parID = 0;
1209	spec.name[0] = 0;
1210	MacFileHelpers::FSSpecFromUnixPath(
1211	inString,
1212	spec,
1213	false,
1214	true, // resolve alias
1215	true,
1216	inCreateDirs);
1217	// Now we have a spec,
1218	// Invoke operator = (const nsFileSpec&) to do the rest.
1219	// Why didn't we just say mPath = inString to get the path? Well, we want it to be
1220	// canonical and absolute.
1221	ioPath = spec;
1222	}
1223
1224	//----------------------------------------------------------------------------------------
1225	nsFilePath::nsFilePath(const char* inString, PRBool inCreateDirs)
1226	//----------------------------------------------------------------------------------------
1227	{
1228	AssignFromPath(*this, inString, inCreateDirs);
1229	} //nsFilePath::nsFilePath
1230
1231	//----------------------------------------------------------------------------------------
1232	nsFilePath::nsFilePath(const nsString& inString, PRBool inCreateDirs)
1233	//----------------------------------------------------------------------------------------
1234	{
1235	AssignFromPath(*this, NS_LossyConvertUCS2toASCII(inString).get(),
1236	inCreateDirs);
1237	}
1238
1239	//----------------------------------------------------------------------------------------
1240	void nsFilePath::operator = (const char* inString)
1241	//----------------------------------------------------------------------------------------
1242	{
1243	AssignFromPath(*this, inString, PR_FALSE);
1244	}
1245
1246	//----------------------------------------------------------------------------------------
1247	nsFilePath::nsFilePath(const nsFileSpec& inSpec)
1248	//----------------------------------------------------------------------------------------
1249	{
1250	*this = inSpec;
1251	}
1252
1253	//----------------------------------------------------------------------------------------
1254	nsFilePath::nsFilePath(const nsFileURL& inOther)
1255	//----------------------------------------------------------------------------------------
1256	{
1257	*this = inOther;
1258	}
1259
1260	//----------------------------------------------------------------------------------------
1261	void nsFilePath::operator = (const nsFileSpec& inSpec)
1262	//----------------------------------------------------------------------------------------
1263	{
1264	char * path = MacFileHelpers::PathNameFromFSSpec(inSpec);
1265	path = MacFileHelpers::EncodeMacPath(path, true, false);
1266	mPath = path;
1267	nsCRT::free(path);
1268	mFileSpec = inSpec;
1269	} // nsFilePath::operator =
1270
1271	//----------------------------------------------------------------------------------------
1272	void nsFilePath::operator = (const nsFileURL& inOther)
1273	//----------------------------------------------------------------------------------------
1274	{
1275	char * path = MacFileHelpers::PathNameFromFSSpec(inOther.mFileSpec);
1276	path = MacFileHelpers::EncodeMacPath(path, true, false);
1277	mPath = path;
1278	nsCRT::free(path);
1279	mFileSpec = inOther.GetFileSpec();
1280	}
1281
1282	#pragma mark -
1283
1284	//========================================================================================
1285	// nsFileURL implementation
1286	//========================================================================================
1287
1288	//----------------------------------------------------------------------------------------
1289	nsFileURL::nsFileURL(const char* inString, PRBool inCreateDirs)
1290	//----------------------------------------------------------------------------------------
1291	: mURL(inString)
1292	{
1293	NS_ASSERTION(inString, "nsFileURL constructed with null inString");
1294	NS_ASSERTION(strstr(inString, kFileURLPrefix) == inString, "Not a URL!");
1295	mFileSpec.mError = NS_FILE_RESULT(MacFileHelpers::FSSpecFromUnixPath(
1296	inString + kFileURLPrefixLength,
1297	mFileSpec.mSpec,
1298	true, // need to decode
1299	false, // resolve alias
1300	false, // must be a full path
1301	inCreateDirs));
1302	if (mFileSpec.mError == NS_FILE_RESULT(fnfErr))
1303	mFileSpec.mError = NS_OK;
1304	} // nsFileURL::nsFileURL
1305
1306	//----------------------------------------------------------------------------------------
1307	nsFileURL::nsFileURL(const nsString& inString, PRBool inCreateDirs)
1308	//----------------------------------------------------------------------------------------
1309	: mURL(nsnull)
1310	{
1311	NS_LossyConvertUCS2toASCII cstring(inString);
1312	mURL = cstring.get();
1313	NS_ASSERTION(strstr(cstring.get(), kFileURLPrefix) == cstring.get(),
1314	"Not a URL!");
1315	mFileSpec.mError = NS_FILE_RESULT(MacFileHelpers::FSSpecFromUnixPath(
1316	cstring.get() + kFileURLPrefixLength,
1317	mFileSpec.mSpec,
1318	true, // need to decode
1319	false, // resolve alias
1320	false, // must be a full path
1321	inCreateDirs));
1322	if (mFileSpec.mError == NS_FILE_RESULT(fnfErr))
1323	mFileSpec.mError = NS_OK;
1324	} // nsFileURL::nsFileURL
1325
1326	//----------------------------------------------------------------------------------------
1327	nsFileURL::nsFileURL(const nsFilePath& inOther)
1328	//----------------------------------------------------------------------------------------
1329	{
1330	*this = inOther.GetFileSpec();
1331	} // nsFileURL::nsFileURL
1332
1333	//----------------------------------------------------------------------------------------
1334	nsFileURL::nsFileURL(const nsFileSpec& inOther)
1335	//----------------------------------------------------------------------------------------
1336	{
1337	*this = inOther;
1338	} // nsFileURL::nsFileURL
1339
1340	//----------------------------------------------------------------------------------------
1341	void nsFileURL::operator = (const nsFilePath& inOther)
1342	//----------------------------------------------------------------------------------------
1343	{
1344	*this = inOther.GetFileSpec();
1345	} // nsFileURL::operator =
1346
1347	//----------------------------------------------------------------------------------------
1348	void nsFileURL::operator = (const nsFileSpec& inOther)
1349	//----------------------------------------------------------------------------------------
1350	{
1351	mFileSpec = inOther;
1352	char* path = MacFileHelpers::PathNameFromFSSpec( mFileSpec );
1353	char* encodedPath = MacFileHelpers::EncodeMacPath(path, true, true);
1354	nsSimpleCharString encodedURL(kFileURLPrefix);
1355	encodedURL += encodedPath;
1356	nsCRT::free(encodedPath);
1357	mURL = encodedURL;
1358	if (encodedURL[encodedURL.Length() - 1] != '/' && inOther.IsDirectory())
1359	mURL += "/";
1360	} // nsFileURL::operator =
1361
1362	//----------------------------------------------------------------------------------------
1363	void nsFileURL::operator = (const char* inString)
1364	//----------------------------------------------------------------------------------------
1365	{
1366	NS_ASSERTION(inString, "nsFileURL operator= constructed with null inString");
1367
1368	mURL = inString;
1369	NS_ASSERTION(strstr(inString, kFileURLPrefix) == inString, "Not a URL!");
1370	mFileSpec.mError = NS_FILE_RESULT(MacFileHelpers::FSSpecFromUnixPath(
1371	inString + kFileURLPrefixLength,
1372	mFileSpec.mSpec,
1373	true, // need to decode
1374	true, // resolve alias
1375	false, // must be a full path
1376	false)); // don't create dirs.
1377	if (mFileSpec.mError == NS_FILE_RESULT(fnfErr))
1378	mFileSpec.mError = NS_OK;
1379	} // nsFileURL::operator =
1380
1381	#pragma mark -
1382
1383	//========================================================================================
1384	// nsDirectoryIterator
1385	//========================================================================================
1386
1387	//----------------------------------------------------------------------------------------
1388	nsDirectoryIterator::nsDirectoryIterator(
1389	const nsFileSpec& inDirectory
1390	, PRBool resolveSymLinks)
1391	//----------------------------------------------------------------------------------------
1392	: mCurrent(inDirectory)
1393	, mExists(false)
1394	, mResoveSymLinks(resolveSymLinks)
1395	, mIndex(-1)
1396	{
1397	CInfoPBRec pb;
1398	OSErr err = inDirectory.GetCatInfo(pb);
1399
1400	// test that we have got a directory back, not a file
1401	DirInfo* dipb = (DirInfo*)&pb;
1402	if (err != noErr \|\| !( dipb->ioFlAttrib & 0x0010))
1403	return;
1404	// Sorry about this, there seems to be a bug in CWPro 4:
1405	FSSpec& currentSpec = mCurrent.nsFileSpec::operator FSSpec&();
1406	mVRefNum = currentSpec.vRefNum;
1407	mParID = dipb->ioDrDirID;
1408	mMaxIndex = pb.dirInfo.ioDrNmFls;
1409	mIndex = 0; // ready to increment
1410	++(*this); // the pre-increment operator
1411
1412	} // nsDirectoryIterator::nsDirectoryIterator
1413
1414	//----------------------------------------------------------------------------------------
1415	OSErr nsDirectoryIterator::SetToIndex()
1416	//----------------------------------------------------------------------------------------
1417	{
1418	CInfoPBRec cipb;
1419	DirInfo dipb=(DirInfo )&cipb;
1420	Str255 objectName;
1421	dipb->ioCompletion = nsnull;
1422	dipb->ioFDirIndex = mIndex;
1423	// Sorry about this, there seems to be a bug in CWPro 4:
1424	FSSpec& currentSpec = mCurrent.nsFileSpec::operator FSSpec&();
1425	dipb->ioVRefNum = mVRefNum; /* Might need to use vRefNum, not sure*/
1426	dipb->ioDrDirID = mParID;
1427	dipb->ioNamePtr = objectName;
1428	OSErr err = PBGetCatInfoSync(&cipb);
1429	FSSpec temp;
1430	if (err == noErr)
1431	err = FSMakeFSSpec(mVRefNum, mParID, objectName, &temp);
1432	mCurrent = temp; // use the operator: it clears the string cache.
1433	mExists = err == noErr;
1434
1435	if (mExists && mResoveSymLinks)
1436	{
1437	PRBool ignore;
1438	mCurrent.ResolveSymlink(ignore);
1439	}
1440	return err;
1441	} // nsDirectoryIterator::SetToIndex()
1442
1443	//----------------------------------------------------------------------------------------
1444	nsDirectoryIterator& nsDirectoryIterator::operator -- ()
1445	//----------------------------------------------------------------------------------------
1446	{
1447	mExists = false;
1448	while (--mIndex > 0)
1449	{
1450	OSErr err = SetToIndex();
1451	if (err == noErr)
1452	break;
1453	}
1454	return *this;
1455	} // nsDirectoryIterator::operator --
1456
1457	//----------------------------------------------------------------------------------------
1458	nsDirectoryIterator& nsDirectoryIterator::operator ++ ()
1459	//----------------------------------------------------------------------------------------
1460	{
1461	mExists = false;
1462	if (mIndex >= 0) // probably trying to use a file as a directory!
1463	while (++mIndex <= mMaxIndex)
1464	{
1465	OSErr err = SetToIndex();
1466	if (err == noErr)
1467	break;
1468	}
1469	return *this;
1470	} // nsDirectoryIterator::operator ++
1471

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

source: vbox/trunk/src/libs/xpcom18a4/xpcom/obsolete/nsFileSpecMac.cpp@ 62375

Download in other formats: