]> git.saurik.com Git - apple/cf.git/blame_incremental - PlugIn.subproj/CFBundle_Resources.c
projects / apple / cf.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
CF-299.35.tar.gz
[apple/cf.git] / PlugIn.subproj / CFBundle_Resources.c
... / ...
CommitLineData
1/*
2 * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
7 *
8 * This file contains Original Code and/or Modifications of Original Code
9 * as defined in and that are subject to the Apple Public Source License
10 * Version 2.0 (the 'License'). You may not use this file except in
11 * compliance with the License. Please obtain a copy of the License at
12 * http://www.opensource.apple.com/apsl/ and read it before using this
13 * file.
14 *
15 * The Original Code and all software distributed under the License are
16 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
17 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
18 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
20 * Please see the License for the specific language governing rights and
21 * limitations under the License.
22 *
23 * @APPLE_LICENSE_HEADER_END@
24 */
25/* CFBundle_Resources.c
26 Copyright 1999-2002, Apple, Inc. All rights reserved.
27 Responsibility: Doug Davidson
28*/
29
30#if defined(__MACOS8__) || defined(__WIN32__)
31#define USE_GETDIRENTRIES 0
32#else
33#define USE_GETDIRENTRIES 1
34#endif
35#define GETDIRENTRIES_CACHE_CAPACITY 100
36
37#include "CFBundle_Internal.h"
38#include <CoreFoundation/CFURLAccess.h>
39#include <CoreFoundation/CFPropertyList.h>
40#include <CoreFoundation/CFByteOrder.h>
41#include <CoreFoundation/CFNumber.h>
42#include <string.h>
43#include "CFInternal.h"
44#include "CFPriv.h"
45
46#if defined(__MACOS8__)
47/* MacOS8 Headers */
48#include <Script.h>
49#include <stat.h>
50#include <Files.h>
51#include <Resources.h>
52#include <CodeFragments.h>
53#include <Errors.h>
54#include <Gestalt.h>
55#else
56/* Unixy & Windows Headers */
57#include <sys/stat.h>
58#include <fcntl.h>
59#include <unistd.h>
60#include <stdio.h>
61#if USE_GETDIRENTRIES
62#include <dirent.h>
63#endif
64#endif
65
66
67
68// All new-style bundles will have these extensions.
69CF_INLINE CFStringRef _CFGetPlatformName(void) {
70 // MF:!!! This used to be based on NSInterfaceStyle, not hard-wired by compiler.
71#if defined(__WIN32__)
72 return _CFBundleWindowsPlatformName;
73#elif defined(__MACOS8__)
74 return _CFBundleMacOS8PlatformName;
75#elif defined (__MACH__)
76 return _CFBundleMacOSXPlatformName;
77#elif defined(__svr4__)
78 return _CFBundleSolarisPlatformName;
79#elif defined(__hpux__)
80 return _CFBundleHPUXPlatformName;
81#elif defined(__LINUX__)
82 return _CFBundleLinuxPlatformName;
83#elif defined(__FREEBSD__)
84 return _CFBundleFreeBSDPlatformName;
85#else
86 return CFSTR("");
87#endif
88}
89
90CF_INLINE CFStringRef _CFGetAlternatePlatformName(void) {
91#if defined (__MACH__)
92 return _CFBundleAlternateMacOSXPlatformName;
93#elif defined(__MACOS8__)
94 return _CFBundleAlternateMacOS8PlatformName;
95#else
96 return CFSTR("");
97#endif
98}
99
100static CFSpinLock_t CFBundleResourceGlobalDataLock = 0;
101static UniChar *_AppSupportUniChars1 = NULL;
102static CFIndex _AppSupportLen1 = 0;
103static UniChar *_AppSupportUniChars2 = NULL;
104static CFIndex _AppSupportLen2 = 0;
105static UniChar *_ResourcesUniChars = NULL;
106static CFIndex _ResourcesLen = 0;
107static UniChar *_PlatformUniChars = NULL;
108static CFIndex _PlatformLen = 0;
109static UniChar *_AlternatePlatformUniChars = NULL;
110static CFIndex _AlternatePlatformLen = 0;
111static UniChar *_LprojUniChars = NULL;
112static CFIndex _LprojLen = 0;
113static UniChar *_GlobalResourcesUniChars = NULL;
114static CFIndex _GlobalResourcesLen = 0;
115static UniChar *_InfoExtensionUniChars = NULL;
116static CFIndex _InfoExtensionLen = 0;
117
118static void _CFBundleInitStaticUniCharBuffers(void) {
119 CFStringRef appSupportStr1 = _CFBundleSupportFilesDirectoryName1;
120 CFStringRef appSupportStr2 = _CFBundleSupportFilesDirectoryName2;
121 CFStringRef resourcesStr = _CFBundleResourcesDirectoryName;
122 CFStringRef platformStr = _CFGetPlatformName();
123 CFStringRef alternatePlatformStr = _CFGetAlternatePlatformName();
124 CFStringRef lprojStr = _CFBundleLprojExtension;
125 CFStringRef globalResourcesStr = _CFBundleNonLocalizedResourcesDirectoryName;
126 CFStringRef infoExtensionStr = _CFBundleInfoExtension;
127
128 CFAllocatorRef alloc = __CFGetDefaultAllocator();
129
130 _AppSupportLen1 = CFStringGetLength(appSupportStr1);
131 _AppSupportLen2 = CFStringGetLength(appSupportStr2);
132 _ResourcesLen = CFStringGetLength(resourcesStr);
133 _PlatformLen = CFStringGetLength(platformStr);
134 _AlternatePlatformLen = CFStringGetLength(alternatePlatformStr);
135 _LprojLen = CFStringGetLength(lprojStr);
136 _GlobalResourcesLen = CFStringGetLength(globalResourcesStr);
137 _InfoExtensionLen = CFStringGetLength(infoExtensionStr);
138
139 _AppSupportUniChars1 = CFAllocatorAllocate(alloc, sizeof(UniChar) * (_AppSupportLen1 + _AppSupportLen2 + _ResourcesLen + _PlatformLen + _AlternatePlatformLen + _LprojLen + _GlobalResourcesLen + _InfoExtensionLen), 0);
140 _AppSupportUniChars2 = _AppSupportUniChars1 + _AppSupportLen1;
141 _ResourcesUniChars = _AppSupportUniChars2 + _AppSupportLen2;
142 _PlatformUniChars = _ResourcesUniChars + _ResourcesLen;
143 _AlternatePlatformUniChars = _PlatformUniChars + _PlatformLen;
144 _LprojUniChars = _AlternatePlatformUniChars + _AlternatePlatformLen;
145 _GlobalResourcesUniChars = _LprojUniChars + _LprojLen;
146 _InfoExtensionUniChars = _GlobalResourcesUniChars + _GlobalResourcesLen;
147
148 if (_AppSupportLen1 > 0) {
149 CFStringGetCharacters(appSupportStr1, CFRangeMake(0, _AppSupportLen1), _AppSupportUniChars1);
150 }
151 if (_AppSupportLen2 > 0) {
152 CFStringGetCharacters(appSupportStr2, CFRangeMake(0, _AppSupportLen2), _AppSupportUniChars2);
153 }
154 if (_ResourcesLen > 0) {
155 CFStringGetCharacters(resourcesStr, CFRangeMake(0, _ResourcesLen), _ResourcesUniChars);
156 }
157 if (_PlatformLen > 0) {
158 CFStringGetCharacters(platformStr, CFRangeMake(0, _PlatformLen), _PlatformUniChars);
159 }
160 if (_AlternatePlatformLen > 0) {
161 CFStringGetCharacters(alternatePlatformStr, CFRangeMake(0, _AlternatePlatformLen), _AlternatePlatformUniChars);
162 }
163 if (_LprojLen > 0) {
164 CFStringGetCharacters(lprojStr, CFRangeMake(0, _LprojLen), _LprojUniChars);
165 }
166 if (_GlobalResourcesLen > 0) {
167 CFStringGetCharacters(globalResourcesStr, CFRangeMake(0, _GlobalResourcesLen), _GlobalResourcesUniChars);
168 }
169 if (_InfoExtensionLen > 0) {
170 CFStringGetCharacters(infoExtensionStr, CFRangeMake(0, _InfoExtensionLen), _InfoExtensionUniChars);
171 }
172}
173
174CF_INLINE void _CFEnsureStaticBuffersInited(void) {
175 __CFSpinLock(&CFBundleResourceGlobalDataLock);
176 if (_AppSupportUniChars1 == NULL) {
177 _CFBundleInitStaticUniCharBuffers();
178 }
179 __CFSpinUnlock(&CFBundleResourceGlobalDataLock);
180}
181
182#if USE_GETDIRENTRIES
183
184static CFMutableDictionaryRef contentsCache = NULL;
185static CFMutableDictionaryRef directoryContentsCache = NULL;
186
187static CFArrayRef _CFBundleCopyDirectoryContentsAtPath(CFStringRef path, Boolean directoriesOnly) {
188 CFArrayRef result = NULL;
189
190 __CFSpinLock(&CFBundleResourceGlobalDataLock);
191 if (directoriesOnly) {
192 if (directoryContentsCache) result = (CFMutableArrayRef)CFDictionaryGetValue(directoryContentsCache, path);
193 } else {
194 if (contentsCache) result = (CFMutableArrayRef)CFDictionaryGetValue(contentsCache, path);
195 }
196 if (result) CFRetain(result);
197 __CFSpinUnlock(&CFBundleResourceGlobalDataLock);
198
199 if (!result) {
200 char cpathBuff[CFMaxPathSize], dirge[8192];
201 CFIndex cpathLen = 0;
202 int fd = -1, numread;
203 long basep = 0;
204 CFMutableArrayRef contents = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks), directoryContents = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
205 CFStringRef name;
206
207 if (_CFStringGetFileSystemRepresentation(path, cpathBuff, CFMaxPathSize)) {
208 cpathLen = strlen(cpathBuff);
209 fd = open(cpathBuff, O_RDONLY, 0777);
210 }
211 if (fd >= 0) {
212 while ((numread = getdirentries(fd, dirge, sizeof(dirge), &basep)) > 0) {
213 struct dirent *dent;
214 for (dent = (struct dirent *)dirge; dent < (struct dirent *)(dirge + numread); dent = (struct dirent *)((char *)dent + dent->d_reclen)) {
215 CFIndex nameLen = strlen(dent->d_name);
216 if (0 == dent->d_fileno || (dent->d_name[0] == '.' && (nameLen == 1 || (nameLen == 2 && dent->d_name[1] == '.')))) continue;
217 name = CFStringCreateWithCString(NULL, dent->d_name, CFStringFileSystemEncoding());
218 if (NULL != name) {
219 CFArrayAppendValue(contents, name);
220 if (dent->d_type == DT_DIR) {
221 CFArrayAppendValue(directoryContents, name);
222 } else if (dent->d_type == DT_UNKNOWN) {
223 struct stat statBuf;
224 cpathBuff[cpathLen] = '/';
225 strncpy(cpathBuff + cpathLen + 1, dent->d_name, nameLen);
226 cpathBuff[cpathLen + nameLen + 1] = '\0';
227 if (stat(cpathBuff, &statBuf) == 0 && (statBuf.st_mode & S_IFMT) == S_IFDIR) CFArrayAppendValue(directoryContents, name);
228 cpathBuff[cpathLen] = '\0';
229 }
230 CFRelease(name);
231 }
232 }
233 }
234 close(fd);
235 }
236
237 __CFSpinLock(&CFBundleResourceGlobalDataLock);
238 if (!contentsCache) contentsCache = CFDictionaryCreateMutable(NULL, GETDIRENTRIES_CACHE_CAPACITY, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
239 if (GETDIRENTRIES_CACHE_CAPACITY == CFDictionaryGetCount(contentsCache)) CFDictionaryRemoveAllValues(contentsCache);
240 CFDictionaryAddValue(contentsCache, path, contents);
241
242 if (!directoryContentsCache) directoryContentsCache = CFDictionaryCreateMutable(NULL, GETDIRENTRIES_CACHE_CAPACITY, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
243 if (GETDIRENTRIES_CACHE_CAPACITY == CFDictionaryGetCount(directoryContentsCache)) CFDictionaryRemoveAllValues(directoryContentsCache);
244 CFDictionaryAddValue(directoryContentsCache, path, directoryContents);
245
246 result = CFRetain(directoriesOnly ? directoryContents : contents);
247 CFRelease(contents);
248 CFRelease(directoryContents);
249 __CFSpinUnlock(&CFBundleResourceGlobalDataLock);
250 }
251
252 return result;
253}
254
255static void _CFBundleFlushContentsCaches(void) {
256 __CFSpinLock(&CFBundleResourceGlobalDataLock);
257 if (contentsCache) CFDictionaryRemoveAllValues(contentsCache);
258 if (directoryContentsCache) CFDictionaryRemoveAllValues(directoryContentsCache);
259 __CFSpinUnlock(&CFBundleResourceGlobalDataLock);
260}
261
262#endif /* USE_GETDIRENTRIES */
263
264CF_EXPORT void _CFBundleFlushCaches(void) {
265#if USE_GETDIRENTRIES
266 _CFBundleFlushContentsCaches();
267#endif /* USE_GETDIRENTRIES */
268}
269
270__private_extern__ Boolean _CFIsResourceAtURL(CFURLRef url, Boolean *isDir) {
271 Boolean exists;
272 SInt32 mode;
273 if (_CFGetFileProperties(NULL, url, &exists, &mode, NULL, NULL, NULL, NULL) == 0) {
274 if (isDir) {
275 *isDir = ((exists && ((mode & S_IFMT) == S_IFDIR)) ? true : false);
276 }
277#if defined(__MACOS8__)
278 return (exists);
279#else
280 return (exists && (mode & 0444));
281#endif /* __MACOS8__ */
282 } else {
283 return false;
284 }
285}
286
287__private_extern__ Boolean _CFIsResourceAtPath(CFStringRef path, Boolean *isDir) {
288 Boolean result = false;
289 CFURLRef url = CFURLCreateWithFileSystemPath(CFGetAllocator(path), path, PLATFORM_PATH_STYLE, false);
290 if (url != NULL) {
291 result = _CFIsResourceAtURL(url, isDir);
292 CFRelease(url);
293 }
294 return result;
295}
296
297static void _CFSearchBundleDirectory(CFAllocatorRef alloc, CFMutableArrayRef result, UniChar *pathUniChars, CFIndex pathLen, UniChar *nameUniChars, CFIndex nameLen, UniChar *typeUniChars, CFIndex typeLen, CFMutableStringRef cheapStr, CFMutableStringRef tmpString, uint8_t version) {
298 // pathUniChars is the full path to the directory we are searching.
299 // nameUniChars is what we are looking for.
300 // typeUniChars is the type we are looking for.
301 // platformUniChars is the platform name.
302 // cheapStr is available for our use for whatever we want.
303 // URLs for found resources get added to result.
304 CFIndex savedPathLen;
305 Boolean platformGenericFound = false, platformSpecificFound = false;
306 Boolean platformGenericIsDir = false, platformSpecificIsDir = false;
307 CFStringRef platformGenericStr = NULL;
308
309#if USE_GETDIRENTRIES
310 CFIndex dirPathLen = pathLen;
311 CFArrayRef contents, directoryContents;
312 CFRange contentsRange, directoryContentsRange;
313
314 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars, dirPathLen, dirPathLen);
315 CFStringReplaceAll(cheapStr, tmpString);
316 //fprintf(stderr, "looking in ");CFShow(cheapStr);
317 contents = _CFBundleCopyDirectoryContentsAtPath(cheapStr, false);
318 contentsRange = CFRangeMake(0, CFArrayGetCount(contents));
319 directoryContents = _CFBundleCopyDirectoryContentsAtPath(cheapStr, true);
320 directoryContentsRange = CFRangeMake(0, CFArrayGetCount(directoryContents));
321#endif
322
323 if (nameLen > 0) {
324 _CFAppendPathComponent(pathUniChars, &pathLen, CFMaxPathSize, nameUniChars, nameLen);
325 }
326 // Save length with just name appended.
327 savedPathLen = pathLen;
328
329 // Check platform generic
330 if (typeLen > 0) {
331 _CFAppendPathExtension(pathUniChars, &pathLen, CFMaxPathSize, typeUniChars, typeLen);
332 }
333#if USE_GETDIRENTRIES
334 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars + dirPathLen + 1, pathLen - dirPathLen - 1, pathLen - dirPathLen - 1);
335 CFStringReplaceAll(cheapStr, tmpString);
336 platformGenericFound = CFArrayContainsValue(contents, contentsRange, cheapStr);
337 platformGenericIsDir = CFArrayContainsValue(directoryContents, directoryContentsRange, cheapStr);
338 //fprintf(stderr, "looking for ");CFShow(cheapStr);if (platformGenericFound) fprintf(stderr, "found it\n"); if (platformGenericIsDir) fprintf(stderr, "a directory\n");
339 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars, pathLen, pathLen);
340 CFStringReplaceAll(cheapStr, tmpString);
341#else
342 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars, pathLen, pathLen);
343 CFStringReplaceAll(cheapStr, tmpString);
344 platformGenericFound = _CFIsResourceAtPath(cheapStr, &platformGenericIsDir);
345#endif
346
347 // Check for platform specific.
348 if (platformGenericFound) {
349 platformGenericStr = CFStringCreateCopy(alloc, cheapStr);
350 if (!platformSpecificFound && (_PlatformLen > 0)) {
351 pathLen = savedPathLen;
352 pathUniChars[pathLen++] = (UniChar)'-';
353 memmove(pathUniChars + pathLen, _PlatformUniChars, _PlatformLen * sizeof(UniChar));
354 pathLen += _PlatformLen;
355 if (typeLen > 0) {
356 _CFAppendPathExtension(pathUniChars, &pathLen, CFMaxPathSize, typeUniChars, typeLen);
357 }
358#if USE_GETDIRENTRIES
359 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars + dirPathLen + 1, pathLen - dirPathLen - 1, pathLen - dirPathLen - 1);
360 CFStringReplaceAll(cheapStr, tmpString);
361 platformSpecificFound = CFArrayContainsValue(contents, contentsRange, cheapStr);
362 platformSpecificIsDir = CFArrayContainsValue(directoryContents, directoryContentsRange, cheapStr);
363 //fprintf(stderr, "looking for ");CFShow(cheapStr);if (platformSpecificFound) fprintf(stderr, "found it\n"); if (platformSpecificIsDir) fprintf(stderr, "a directory\n");
364 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars, pathLen, pathLen);
365 CFStringReplaceAll(cheapStr, tmpString);
366#else
367 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars, pathLen, pathLen);
368 CFStringReplaceAll(cheapStr, tmpString);
369 platformSpecificFound = _CFIsResourceAtPath(cheapStr, &platformSpecificIsDir);
370#endif
371 }
372 }
373 if (platformSpecificFound) {
374 CFURLRef url = CFURLCreateWithFileSystemPath(alloc, cheapStr, PLATFORM_PATH_STYLE, platformSpecificIsDir);
375 CFArrayAppendValue(result, url);
376 CFRelease(url);
377 } else if (platformGenericFound) {
378 CFURLRef url = CFURLCreateWithFileSystemPath(alloc, ((platformGenericStr != NULL) ? platformGenericStr : cheapStr), PLATFORM_PATH_STYLE, platformGenericIsDir);
379 CFArrayAppendValue(result, url);
380 CFRelease(url);
381 }
382 if (platformGenericStr != NULL) {
383 CFRelease(platformGenericStr);
384 }
385#if USE_GETDIRENTRIES
386 CFRelease(contents);
387 CFRelease(directoryContents);
388#endif
389}
390
391static void _CFFindBundleResourcesInRawDir(CFAllocatorRef alloc, UniChar *workingUniChars, CFIndex workingLen, UniChar *nameUniChars, CFIndex nameLen, CFArrayRef resTypes, CFIndex limit, uint8_t version, CFMutableStringRef cheapStr, CFMutableStringRef tmpString, CFMutableArrayRef result) {
392
393 if (nameLen > 0) {
394 // If we have a resName, just call the search API. We may have to loop over the resTypes.
395 if (!resTypes) {
396 _CFSearchBundleDirectory(alloc, result, workingUniChars, workingLen, nameUniChars, nameLen, NULL, 0, cheapStr, tmpString, version);
397 } else {
398 CFIndex i, c = CFArrayGetCount(resTypes);
399 for (i=0; i<c; i++) {
400 CFStringRef curType = (CFStringRef)CFArrayGetValueAtIndex(resTypes, i);
401 CFIndex typeLen = CFStringGetLength(curType);
402#if defined(__MACOS8__) || defined(__WIN32__)
403 UniChar *typeChars = CFAllocatorAllocate(alloc, sizeof(UniChar) * typeLen, 0);
404 if (typeChars) {
405#else
406 UniChar typeChars[typeLen];
407#endif /* __MACOS8__ */
408 CFStringGetCharacters(curType, CFRangeMake(0, typeLen), typeChars);
409 _CFSearchBundleDirectory(alloc, result, workingUniChars, workingLen, nameUniChars, nameLen, typeChars, typeLen, cheapStr, tmpString, version);
410 if (limit <= CFArrayGetCount(result)) {
411 break;
412 }
413#if defined(__MACOS8__) || defined(__WIN32__)
414 CFAllocatorDeallocate(alloc, typeChars);
415 }
416#endif /* __MACOS8__ */
417 }
418 }
419 } else {
420 // If we have no resName, do it by hand. We may have to loop over the resTypes.
421 unsigned char cpathBuff[CFMaxPathSize];
422 CFIndex cpathLen;
423 CFMutableArrayRef children;
424
425 CFStringSetExternalCharactersNoCopy(tmpString, workingUniChars, workingLen, workingLen);
426 if (!_CFStringGetFileSystemRepresentation(tmpString, cpathBuff, CFMaxPathSize)) return;
427 cpathLen = strlen(cpathBuff);
428
429 if (!resTypes) {
430 children = _CFContentsOfDirectory(alloc, cpathBuff, NULL, NULL, NULL);
431 if (children) {
432 CFIndex childIndex, childCount = CFArrayGetCount(children);
433 for (childIndex = 0; childIndex < childCount; childIndex++) {
434 CFArrayAppendValue(result, CFArrayGetValueAtIndex(children, childIndex));
435 }
436 CFRelease(children);
437 }
438 } else {
439 CFIndex i, c = CFArrayGetCount(resTypes);
440 for (i=0; i<c; i++) {
441 CFStringRef curType = (CFStringRef)CFArrayGetValueAtIndex(resTypes, i);
442
443 children = _CFContentsOfDirectory(alloc, cpathBuff, NULL, NULL, curType);
444 if (children) {
445 CFIndex childIndex, childCount = CFArrayGetCount(children);
446 for (childIndex = 0; childIndex < childCount; childIndex++) {
447 CFArrayAppendValue(result, CFArrayGetValueAtIndex(children, childIndex));
448 }
449 CFRelease(children);
450 }
451 if (limit <= CFArrayGetCount(result)) {
452 break;
453 }
454 }
455 }
456 }
457}
458
459static void _CFFindBundleResourcesInResourcesDir(CFAllocatorRef alloc, UniChar *workingUniChars, CFIndex workingLen, UniChar *subDirUniChars, CFIndex subDirLen, CFArrayRef searchLanguages, UniChar *nameUniChars, CFIndex nameLen, CFArrayRef resTypes, CFIndex limit, uint8_t version, CFMutableStringRef cheapStr, CFMutableStringRef tmpString, CFMutableArrayRef result) {
460 CFIndex savedWorkingLen = workingLen;
461
462 // Look directly in the directory specified in workingUniChars. as if it is a Resources directory.
463 if (1 == version) {
464 // Add the non-localized resource directory.
465 _CFAppendPathComponent(workingUniChars, &workingLen, CFMaxPathSize, _GlobalResourcesUniChars, _GlobalResourcesLen);
466 if (subDirLen > 0) {
467 _CFAppendPathComponent(workingUniChars, &workingLen, CFMaxPathSize, subDirUniChars, subDirLen);
468 }
469 _CFFindBundleResourcesInRawDir(alloc, workingUniChars, workingLen, nameUniChars, nameLen, resTypes, limit, version, cheapStr, tmpString, result);
470
471 // Strip the non-localized resource directory.
472 workingLen = savedWorkingLen;
473 }
474 if (CFArrayGetCount(result) < limit) {
475 if (subDirLen > 0) {
476 _CFAppendPathComponent(workingUniChars, &workingLen, CFMaxPathSize, subDirUniChars, subDirLen);
477 }
478 _CFFindBundleResourcesInRawDir(alloc, workingUniChars, workingLen, nameUniChars, nameLen, resTypes, limit, version, cheapStr, tmpString, result);
479 }
480
481 // Now search the local resources.
482 workingLen = savedWorkingLen;
483 if (CFArrayGetCount(result) < limit) {
484 CFIndex langIndex;
485 CFIndex langCount = (searchLanguages ? CFArrayGetCount(searchLanguages) : 0);
486 CFStringRef curLangStr;
487 CFIndex curLangLen;
488 // MF:??? OK to hard-wire this length?
489 UniChar curLangUniChars[255];
490 CFIndex numResults = CFArrayGetCount(result);
491
492 for (langIndex = 0; langIndex < langCount; langIndex++) {
493 curLangStr = CFArrayGetValueAtIndex(searchLanguages, langIndex);
494 curLangLen = CFStringGetLength(curLangStr);
495 CFStringGetCharacters(curLangStr, CFRangeMake(0, curLangLen), curLangUniChars);
496 savedWorkingLen = workingLen;
497 if (!_CFAppendPathComponent(workingUniChars, &workingLen, CFMaxPathSize, curLangUniChars, curLangLen)) {
498 workingLen = savedWorkingLen;
499 continue;
500 }
501 if (!_CFAppendPathExtension(workingUniChars, &workingLen, CFMaxPathSize, _LprojUniChars, _LprojLen)) {
502 workingLen = savedWorkingLen;
503 continue;
504 }
505 if (subDirLen > 0) {
506 if (!_CFAppendPathComponent(workingUniChars, &workingLen, CFMaxPathSize, subDirUniChars, subDirLen)) {
507 workingLen = savedWorkingLen;
508 continue;
509 }
510 }
511 _CFFindBundleResourcesInRawDir(alloc, workingUniChars, workingLen, nameUniChars, nameLen, resTypes, limit, version, cheapStr, tmpString, result);
512
513 // Back off this lproj component
514 workingLen = savedWorkingLen;
515 if (CFArrayGetCount(result) != numResults) {
516 // We found resources in a language we already searched. Don't look any farther.
517 // We also don't need to check the limit, since if the count changed at all, we are bailing.
518 break;
519 }
520 }
521 }
522}
523
524extern void _CFStrSetDesiredCapacity(CFMutableStringRef str, CFIndex len);
525
526CFArrayRef _CFFindBundleResources(CFBundleRef bundle, CFURLRef bundleURL, CFStringRef subDirName, CFArrayRef searchLanguages, CFStringRef resName, CFArrayRef resTypes, CFIndex limit, uint8_t version) {
527 CFAllocatorRef alloc = ((bundle != NULL) ? CFGetAllocator(bundle) : CFRetain(__CFGetDefaultAllocator()));
528 CFMutableArrayRef result;
529 UniChar *workingUniChars, *nameUniChars, *subDirUniChars;
530 CFIndex nameLen = (resName ? CFStringGetLength(resName) : 0);
531 CFIndex subDirLen = (subDirName ? CFStringGetLength(subDirName) : 0);
532 CFIndex workingLen, savedWorkingLen;
533 CFURLRef absoluteURL;
534 CFStringRef bundlePath;
535 CFMutableStringRef cheapStr, tmpString;
536
537 result = CFArrayCreateMutable(alloc, 0, &kCFTypeArrayCallBacks);
538 // Init the one-time-only unichar buffers.
539 _CFEnsureStaticBuffersInited();
540
541 // Build UniChar buffers for some of the string pieces we need.
542 // One malloc will do.
543 nameUniChars = CFAllocatorAllocate(alloc, sizeof(UniChar) * (nameLen + subDirLen + CFMaxPathSize), 0);
544 subDirUniChars = nameUniChars + nameLen;
545 workingUniChars = subDirUniChars + subDirLen;
546
547 if (nameLen > 0) {
548 CFStringGetCharacters(resName, CFRangeMake(0, nameLen), nameUniChars);
549 }
550 if (subDirLen > 0) {
551 CFStringGetCharacters(subDirName, CFRangeMake(0, subDirLen), subDirUniChars);
552 }
553 // Build a UniChar buffer with the absolute path to the bundle's resources directory.
554 // If no URL was passed, we get it from the bundle.
555 bundleURL = ((bundleURL != NULL) ? CFRetain(bundleURL) : CFBundleCopyBundleURL(bundle));
556 absoluteURL = CFURLCopyAbsoluteURL(bundleURL);
557 bundlePath = CFURLCopyFileSystemPath(absoluteURL, PLATFORM_PATH_STYLE);
558 CFRelease(absoluteURL);
559 if ((workingLen = CFStringGetLength(bundlePath)) > 0) {
560 CFStringGetCharacters(bundlePath, CFRangeMake(0, workingLen), workingUniChars);
561 }
562 CFRelease(bundlePath);
563 CFRelease(bundleURL);
564 savedWorkingLen = workingLen;
565 if (1 == version) {
566 _CFAppendPathComponent(workingUniChars, &workingLen, CFMaxPathSize, _AppSupportUniChars1, _AppSupportLen1);
567 } else if (2 == version) {
568 _CFAppendPathComponent(workingUniChars, &workingLen, CFMaxPathSize, _AppSupportUniChars2, _AppSupportLen2);
569 }
570 if (0 == version || 1 == version || 2 == version) {
571 _CFAppendPathComponent(workingUniChars, &workingLen, CFMaxPathSize, _ResourcesUniChars, _ResourcesLen);
572 }
573
574 // both of these used for temp string operations, for slightly
575 // different purposes, where each type is appropriate
576 cheapStr = CFStringCreateMutable(alloc, 0);
577 _CFStrSetDesiredCapacity(cheapStr, CFMaxPathSize);
578 tmpString = CFStringCreateMutableWithExternalCharactersNoCopy(kCFAllocatorSystemDefault, NULL, 0, 0, kCFAllocatorNull);
579
580 _CFFindBundleResourcesInResourcesDir(alloc, workingUniChars, workingLen, subDirUniChars, subDirLen, searchLanguages, nameUniChars, nameLen, resTypes, limit, version, cheapStr, tmpString, result);
581
582 // drd: This unfortunate hack is still necessary because of installer packages
583 if (0 == version && CFArrayGetCount(result) == 0) {
584 // Try looking directly in the bundle path
585 workingLen = savedWorkingLen;
586 _CFFindBundleResourcesInResourcesDir(alloc, workingUniChars, workingLen, subDirUniChars, subDirLen, searchLanguages, nameUniChars, nameLen, resTypes, limit, version, cheapStr, tmpString, result);
587 }
588
589 CFRelease(cheapStr);
590 CFRelease(tmpString);
591 CFAllocatorDeallocate(alloc, nameUniChars);
592 if (bundle == NULL) {
593 CFRelease(alloc);
594 }
595
596 return result;
597}
598
599CF_EXPORT CFURLRef CFBundleCopyResourceURL(CFBundleRef bundle, CFStringRef resourceName, CFStringRef resourceType, CFStringRef subDirName) {
600 CFURLRef result = NULL;
601 CFArrayRef languages = _CFBundleGetLanguageSearchList(bundle);
602 CFMutableArrayRef types = NULL;
603 CFArrayRef array;
604
605 if (resourceType) {
606 types = CFArrayCreateMutable(CFGetAllocator(bundle), 1, &kCFTypeArrayCallBacks);
607 CFArrayAppendValue(types, resourceType);
608 }
609
610 array = _CFFindBundleResources(bundle, NULL, subDirName, languages, resourceName, types, 1, _CFBundleLayoutVersion(bundle));
611
612 if (types) {
613 CFRelease(types);
614 }
615
616 if (array) {
617 if (CFArrayGetCount(array) > 0) {
618 result = CFRetain(CFArrayGetValueAtIndex(array, 0));
619 }
620 CFRelease(array);
621 }
622 return result;
623}
624
625CF_EXPORT CFArrayRef CFBundleCopyResourceURLsOfType(CFBundleRef bundle, CFStringRef resourceType, CFStringRef subDirName) {
626 CFArrayRef languages = _CFBundleGetLanguageSearchList(bundle);
627 CFMutableArrayRef types = NULL;
628 CFArrayRef array;
629
630 if (resourceType) {
631 types = CFArrayCreateMutable(CFGetAllocator(bundle), 1, &kCFTypeArrayCallBacks);
632 CFArrayAppendValue(types, resourceType);
633 }
634
635 // MF:!!! Better "limit" than 1,000,000?
636 array = _CFFindBundleResources(bundle, NULL, subDirName, languages, NULL, types, 1000000, _CFBundleLayoutVersion(bundle));
637
638 if (types) {
639 CFRelease(types);
640 }
641
642 return array;
643}
644
645CF_EXPORT CFURLRef _CFBundleCopyResourceURLForLanguage(CFBundleRef bundle, CFStringRef resourceName, CFStringRef resourceType, CFStringRef subDirName, CFStringRef language) {return CFBundleCopyResourceURLForLocalization(bundle, resourceName, resourceType, subDirName, language);}
646
647CF_EXPORT CFURLRef CFBundleCopyResourceURLForLocalization(CFBundleRef bundle, CFStringRef resourceName, CFStringRef resourceType, CFStringRef subDirName, CFStringRef localizationName) {
648 CFURLRef result = NULL;
649 CFMutableArrayRef languages = CFArrayCreateMutable(CFGetAllocator(bundle), 1, &kCFTypeArrayCallBacks);
650 CFMutableArrayRef types = NULL;
651 CFArrayRef array;
652
653 if (localizationName) CFArrayAppendValue(languages, localizationName);
654
655 if (resourceType) {
656 types = CFArrayCreateMutable(CFGetAllocator(bundle), 1, &kCFTypeArrayCallBacks);
657 CFArrayAppendValue(types, resourceType);
658 }
659
660 array = _CFFindBundleResources(bundle, NULL, subDirName, languages, resourceName, types, 1, _CFBundleLayoutVersion(bundle));
661
662 if (types) {
663 CFRelease(types);
664 }
665
666 if (array) {
667 if (CFArrayGetCount(array) > 0) {
668 result = CFRetain(CFArrayGetValueAtIndex(array, 0));
669 }
670 CFRelease(array);
671 }
672
673 CFRelease(languages);
674
675 return result;
676}
677
678CF_EXPORT CFArrayRef _CFBundleCopyResourceURLsOfTypeForLanguage(CFBundleRef bundle, CFStringRef resourceType, CFStringRef subDirName, CFStringRef language) {return CFBundleCopyResourceURLsOfTypeForLocalization(bundle, resourceType, subDirName, language);}
679
680CF_EXPORT CFArrayRef CFBundleCopyResourceURLsOfTypeForLocalization(CFBundleRef bundle, CFStringRef resourceType, CFStringRef subDirName, CFStringRef localizationName) {
681 CFMutableArrayRef languages = CFArrayCreateMutable(CFGetAllocator(bundle), 1, &kCFTypeArrayCallBacks);
682 CFMutableArrayRef types = NULL;
683 CFArrayRef array;
684
685 if (localizationName) CFArrayAppendValue(languages, localizationName);
686
687 if (resourceType) {
688 types = CFArrayCreateMutable(CFGetAllocator(bundle), 1, &kCFTypeArrayCallBacks);
689 CFArrayAppendValue(types, resourceType);
690 }
691
692 // MF:!!! Better "limit" than 1,000,000?
693 array = _CFFindBundleResources(bundle, NULL, subDirName, languages, NULL, types, 1000000, _CFBundleLayoutVersion(bundle));
694
695 if (types) {
696 CFRelease(types);
697 }
698
699 CFRelease(languages);
700
701 return array;
702}
703
704CF_EXPORT CFStringRef CFBundleCopyLocalizedString(CFBundleRef bundle, CFStringRef key, CFStringRef value, CFStringRef tableName) {
705 CFStringRef result = NULL;
706 CFDictionaryRef stringTable = NULL;
707
708 if (key == NULL) return (value ? CFRetain(value) : CFRetain(CFSTR("")));
709
710 if ((tableName == NULL) || CFEqual(tableName, CFSTR(""))) {
711 tableName = _CFBundleDefaultStringTableName;
712 }
713 if (__CFBundleGetResourceData(bundle)->_stringTableCache != NULL) {
714 // See if we have the table cached.
715 stringTable = CFDictionaryGetValue(__CFBundleGetResourceData(bundle)->_stringTableCache, tableName);
716 }
717 if (stringTable == NULL) {
718 // Go load the table.
719 CFURLRef tableURL = CFBundleCopyResourceURL(bundle, tableName, _CFBundleStringTableType, NULL);
720 if (tableURL) {
721 CFStringRef nameForSharing = NULL;
722 if (stringTable == NULL) {
723 CFDataRef tableData = NULL;
724 SInt32 errCode;
725 CFStringRef errStr;
726 if (CFURLCreateDataAndPropertiesFromResource(CFGetAllocator(bundle), tableURL, &tableData, NULL, NULL, &errCode)) {
727 stringTable = CFPropertyListCreateFromXMLData(CFGetAllocator(bundle), tableData, kCFPropertyListImmutable, &errStr);
728 if (errStr != NULL) {
729 CFRelease(errStr);
730 errStr = NULL;
731 }
732 CFRelease(tableData);
733 }
734 }
735 if (nameForSharing) CFRelease(nameForSharing);
736 CFRelease(tableURL);
737 }
738 if (stringTable == NULL) {
739 stringTable = CFDictionaryCreate(CFGetAllocator(bundle), NULL, NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
740 }
741 if (__CFBundleGetResourceData(bundle)->_stringTableCache == NULL) {
742 __CFBundleGetResourceData(bundle)->_stringTableCache = CFDictionaryCreateMutable(CFGetAllocator(bundle), 0, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
743 }
744 CFDictionarySetValue(__CFBundleGetResourceData(bundle)->_stringTableCache, tableName, stringTable);
745 CFRelease(stringTable);
746 }
747
748 result = CFDictionaryGetValue(stringTable, key);
749 if (result == NULL) {
750 if (value == NULL) {
751 result = CFRetain(key);
752 } else if (CFEqual(value, CFSTR(""))) {
753 result = CFRetain(key);
754 } else {
755 result = CFRetain(value);
756 }
757 } else {
758 CFRetain(result);
759 }
760
761 return result;
762}
763
764CF_EXPORT CFURLRef CFBundleCopyResourceURLInDirectory(CFURLRef bundleURL, CFStringRef resourceName, CFStringRef resourceType, CFStringRef subDirName) {
765 CFURLRef result = NULL;
766 char buff[CFMaxPathSize];
767 CFURLRef newURL = NULL;
768
769 if (!CFURLGetFileSystemRepresentation(bundleURL, true, buff, CFMaxPathSize)) return NULL;
770
771 newURL = CFURLCreateFromFileSystemRepresentation(NULL, buff, strlen(buff), true);
772 if (NULL == newURL) {
773 newURL = CFRetain(bundleURL);
774 }
775 if (_CFBundleCouldBeBundle(newURL)) {
776 uint8_t version = 0;
777 CFArrayRef languages = _CFBundleCopyLanguageSearchListInDirectory(NULL, newURL, &version);
778 CFMutableArrayRef types = NULL;
779 CFArrayRef array;
780
781 if (resourceType) {
782 types = CFArrayCreateMutable(NULL, 1, &kCFTypeArrayCallBacks);
783 CFArrayAppendValue(types, resourceType);
784 }
785
786 array = _CFFindBundleResources(NULL, newURL, subDirName, languages, resourceName, types, 1, version);
787
788 if (types) {
789 CFRelease(types);
790 }
791
792 CFRelease(languages);
793
794 if (array) {
795 if (CFArrayGetCount(array) > 0) {
796 result = CFRetain(CFArrayGetValueAtIndex(array, 0));
797 }
798 CFRelease(array);
799 }
800 }
801 if (newURL) CFRelease(newURL);
802 return result;
803}
804
805CF_EXPORT CFArrayRef CFBundleCopyResourceURLsOfTypeInDirectory(CFURLRef bundleURL, CFStringRef resourceType, CFStringRef subDirName) {
806 CFArrayRef array = NULL;
807 char buff[CFMaxPathSize];
808 CFURLRef newURL = NULL;
809
810 if (!CFURLGetFileSystemRepresentation(bundleURL, true, buff, CFMaxPathSize)) return NULL;
811
812 newURL = CFURLCreateFromFileSystemRepresentation(NULL, buff, strlen(buff), true);
813 if (NULL == newURL) {
814 newURL = CFRetain(bundleURL);
815 }
816 if (_CFBundleCouldBeBundle(newURL)) {
817 uint8_t version = 0;
818 CFArrayRef languages = _CFBundleCopyLanguageSearchListInDirectory(NULL, newURL, &version);
819 CFMutableArrayRef types = NULL;
820
821 if (resourceType) {
822 types = CFArrayCreateMutable(NULL, 1, &kCFTypeArrayCallBacks);
823 CFArrayAppendValue(types, resourceType);
824 }
825
826 // MF:!!! Better "limit" than 1,000,000?
827 array = _CFFindBundleResources(NULL, newURL, subDirName, languages, NULL, types, 1000000, version);
828
829 if (types) {
830 CFRelease(types);
831 }
832
833 CFRelease(languages);
834 }
835 if (newURL) CFRelease(newURL);
836 return array;
837}
838
839// string, with groups of 6 characters being 1 element in the array of locale abbreviations
840const char * __CFBundleLocaleAbbreviationsArray =
841 "en_US\0" "fr_FR\0" "en_GB\0" "de_DE\0" "it_IT\0" "nl_NL\0" "nl_BE\0" "sv_SE\0"
842 "es_ES\0" "da_DK\0" "pt_PT\0" "fr_CA\0" "no_NO\0" "he_IL\0" "ja_JP\0" "en_AU\0"
843 "ar\0\0\0\0" "fi_FI\0" "fr_CH\0" "de_CH\0" "el_GR\0" "is_IS\0" "mt_MT\0" "\0\0\0\0\0\0"
844 "tr_TR\0" "hr_HR\0" "nl_NL\0" "nl_BE\0" "en_CA\0" "en_CA\0" "pt_PT\0" "no_NO\0"
845 "da_DK\0" "hi_IN\0" "ur_PK\0" "tr_TR\0" "it_CH\0" "en\0\0\0\0" "\0\0\0\0\0\0" "ro_RO\0"
846 "el_GR\0" "lt_LT\0" "pl_PL\0" "hu_HU\0" "et_EE\0" "lv_LV\0" "se\0\0\0\0" "fo_FO\0"
847 "fa_IR\0" "ru_RU\0" "ga_IE\0" "ko_KR\0" "zh_CN\0" "zh_TW\0" "th_TH\0" "\0\0\0\0\0\0"
848 "cs_CZ\0" "sk_SK\0" "\0\0\0\0\0\0" "hu_HU\0" "bn\0\0\0\0" "be_BY\0" "uk_UA\0" "\0\0\0\0\0\0"
849 "el_GR\0" "sr_YU\0" "sl_SI\0" "mk_MK\0" "hr_HR\0" "\0\0\0\0\0\0" "de_DE\0" "pt_BR\0"
850 "bg_BG\0" "ca_ES\0" "\0\0\0\0\0\0" "gd\0\0\0\0" "gv\0\0\0\0" "br\0\0\0\0" "iu_CA\0" "cy\0\0\0\0"
851 "en_CA\0" "ga_IE\0" "en_CA\0" "dz_BT\0" "hy_AM\0" "ka_GE\0" "es\0\0\0\0" "es_ES\0"
852 "to_TO\0" "pl_PL\0" "ca_ES\0" "fr\0\0\0\0" "de_AT\0" "es\0\0\0\0" "gu_IN\0" "pa\0\0\0\0"
853 "ur_IN\0" "vi_VN\0" "fr_BE\0" "uz_UZ\0" "\0\0\0\0\0\0" "\0\0\0\0\0\0" "af_ZA\0" "eo\0\0\0\0"
854 "mr_IN\0" "bo\0\0\0\0" "ne_NP\0" "kl\0\0\0";
855
856#define NUM_LOCALE_ABBREVIATIONS 108
857#define LOCALE_ABBREVIATION_LENGTH 6
858
859static const char * const __CFBundleLanguageNamesArray[] = {
860 "English", "French", "German", "Italian", "Dutch", "Swedish", "Spanish", "Danish",
861 "Portuguese", "Norwegian", "Hebrew", "Japanese", "Arabic", "Finnish", "Greek", "Icelandic",
862 "Maltese", "Turkish", "Croatian", "Chinese", "Urdu", "Hindi", "Thai", "Korean",
863 "Lithuanian", "Polish", "Hungarian", "Estonian", "Latvian", "Sami", "Faroese", "Farsi",
864 "Russian", "Chinese", "Dutch", "Irish", "Albanian", "Romanian", "Czech", "Slovak",
865 "Slovenian", "Yiddish", "Serbian", "Macedonian", "Bulgarian", "Ukrainian", "Byelorussian", "Uzbek",
866 "Kazakh", "Azerbaijani", "Azerbaijani", "Armenian", "Georgian", "Moldavian", "Kirghiz", "Tajiki",
867 "Turkmen", "Mongolian", "Mongolian", "Pashto", "Kurdish", "Kashmiri", "Sindhi", "Tibetan",
868 "Nepali", "Sanskrit", "Marathi", "Bengali", "Assamese", "Gujarati", "Punjabi", "Oriya",
869 "Malayalam", "Kannada", "Tamil", "Telugu", "Sinhalese", "Burmese", "Khmer", "Lao",
870 "Vietnamese", "Indonesian", "Tagalog", "Malay", "Malay", "Amharic", "Tigrinya", "Oromo",
871 "Somali", "Swahili", "Kinyarwanda", "Rundi", "Nyanja", "Malagasy", "Esperanto", "",
872 "", "", "", "", "", "", "", "",
873 "", "", "", "", "", "", "", "",
874 "", "", "", "", "", "", "", "",
875 "", "", "", "", "", "", "", "",
876 "Welsh", "Basque", "Catalan", "Latin", "Quechua", "Guarani", "Aymara", "Tatar",
877 "Uighur", "Dzongkha", "Javanese", "Sundanese", "Galician", "Afrikaans", "Breton", "Inuktitut",
878 "Scottish", "Manx", "Irish", "Tongan", "Greek", "Greenlandic", "Azerbaijani"
879};
880
881#define NUM_LANGUAGE_NAMES 151
882#define LANGUAGE_NAME_LENGTH 13
883
884// string, with groups of 3 characters being 1 element in the array of abbreviations
885const char * __CFBundleLanguageAbbreviationsArray =
886 "en\0" "fr\0" "de\0" "it\0" "nl\0" "sv\0" "es\0" "da\0"
887 "pt\0" "no\0" "he\0" "ja\0" "ar\0" "fi\0" "el\0" "is\0"
888 "mt\0" "tr\0" "hr\0" "zh\0" "ur\0" "hi\0" "th\0" "ko\0"
889 "lt\0" "pl\0" "hu\0" "et\0" "lv\0" "se\0" "fo\0" "fa\0"
890 "ru\0" "zh\0" "nl\0" "ga\0" "sq\0" "ro\0" "cs\0" "sk\0"
891 "sl\0" "yi\0" "sr\0" "mk\0" "bg\0" "uk\0" "be\0" "uz\0"
892 "kk\0" "az\0" "az\0" "hy\0" "ka\0" "mo\0" "ky\0" "tg\0"
893 "tk\0" "mn\0" "mn\0" "ps\0" "ku\0" "ks\0" "sd\0" "bo\0"
894 "ne\0" "sa\0" "mr\0" "bn\0" "as\0" "gu\0" "pa\0" "or\0"
895 "ml\0" "kn\0" "ta\0" "te\0" "si\0" "my\0" "km\0" "lo\0"
896 "vi\0" "id\0" "tl\0" "ms\0" "ms\0" "am\0" "ti\0" "om\0"
897 "so\0" "sw\0" "rw\0" "rn\0" "\0\0\0" "mg\0" "eo\0" "\0\0\0"
898 "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0"
899 "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0"
900 "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0"
901 "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0" "\0\0\0"
902 "cy\0" "eu\0" "ca\0" "la\0" "qu\0" "gn\0" "ay\0" "tt\0"
903 "ug\0" "dz\0" "jv\0" "su\0" "gl\0" "af\0" "br\0" "iu\0"
904 "gd\0" "gv\0" "ga\0" "to\0" "el\0" "kl\0" "az\0";
905
906#define NUM_LANGUAGE_ABBREVIATIONS 151
907#define LANGUAGE_ABBREVIATION_LENGTH 3
908
909static const SInt32 __CFBundleScriptCodesArray[] = {
910 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 1, 4, 0, 0, 0,
911 0, 0, 0, 2, 4, 9, 21, 3, 29, 29, 29, 29, 29, 0, 0, 4,
912 7, 25, 0, 0, 0, 0, 29, 29, 0, 5, 7, 7, 7, 7, 7, 7,
913 7, 7, 4, 24, 23, 7, 7, 7, 7, 27, 7, 4, 4, 4, 4, 26,
914 9, 9, 9, 13, 13, 11, 10, 12, 17, 16, 14, 15, 18, 19, 20, 22,
915 30, 0, 0, 0, 4, 28, 28, 28, 0, 0, 0, 0, 0, 0, 0, 0,
916 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
917 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
918 0, 0, 0, 0, 0, 0, 0, 7, 4, 26, 0, 0, 0, 0, 0, 28,
919 0, 0, 0, 0, 6, 0, 0
920};
921
922static const CFStringEncoding __CFBundleStringEncodingsArray[] = {
923 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 1, 4, 0, 6, 37,
924 0, 35, 36, 2, 4, 9, 21, 3, 29, 29, 29, 29, 29, 0, 37, 0x8C,
925 7, 25, 0, 39, 0, 38, 29, 29, 36, 5, 7, 7, 7, 0x98, 7, 7,
926 7, 7, 4, 24, 23, 7, 7, 7, 7, 27, 7, 4, 4, 4, 4, 26,
927 9, 9, 9, 13, 13, 11, 10, 12, 17, 16, 14, 15, 18, 19, 20, 22,
928 30, 0, 0, 0, 4, 28, 28, 28, 0, 0, 0, 0, 0, 0, 0, 0,
929 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
930 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
931 39, 0, 0, 0, 0, 0, 0, 7, 4, 26, 0, 0, 0, 0, 39, 0xEC,
932 39, 39, 40, 0, 6, 0, 0
933};
934
935static SInt32 _CFBundleGetLanguageCodeForLocalization(CFStringRef localizationName) {
936 SInt32 result = -1, i;
937 char buff[256];
938 CFIndex length = CFStringGetLength(localizationName);
939 if ((length >= LANGUAGE_ABBREVIATION_LENGTH - 1) && (length <= 255) && CFStringGetCString(localizationName, buff, 255, kCFStringEncodingASCII)) {
940 buff[255] = '\0';
941 for (i = 0; -1 == result && i < NUM_LANGUAGE_NAMES; i++) {
942 if (0 == strcmp(buff, __CFBundleLanguageNamesArray[i])) result = i;
943 }
944 if (0 == strcmp(buff, "zh_CN")) result = 33; // hack for mixed-up Chinese language codes
945 buff[LANGUAGE_ABBREVIATION_LENGTH - 1] = '\0';
946 for (i = 0; -1 == result && i < NUM_LANGUAGE_ABBREVIATIONS * LANGUAGE_ABBREVIATION_LENGTH; i += LANGUAGE_ABBREVIATION_LENGTH) {
947 if (buff[0] == *(__CFBundleLanguageAbbreviationsArray + i + 0) && buff[1] == *(__CFBundleLanguageAbbreviationsArray + i + 1)) result = i / LANGUAGE_ABBREVIATION_LENGTH;
948 }
949 }
950 return result;
951}
952
953static CFStringRef _CFBundleCopyLanguageAbbreviationForLanguageCode(SInt32 languageCode) {
954 CFStringRef result = NULL;
955 if (0 <= languageCode && languageCode < NUM_LANGUAGE_ABBREVIATIONS) {
956 const char *languageAbbreviation = __CFBundleLanguageAbbreviationsArray + languageCode * LANGUAGE_ABBREVIATION_LENGTH;
957 if (languageAbbreviation != NULL && *languageAbbreviation != '\0') {
958 result = CFStringCreateWithCStringNoCopy(NULL, languageAbbreviation, kCFStringEncodingASCII, kCFAllocatorNull);
959 }
960 }
961 return result;
962}
963
964static CFStringRef _CFBundleCopyLanguageNameForLanguageCode(SInt32 languageCode) {
965 CFStringRef result = NULL;
966 if (0 <= languageCode && languageCode < NUM_LANGUAGE_NAMES) {
967 const char *languageName = __CFBundleLanguageNamesArray[languageCode];
968 if (languageName != NULL && *languageName != '\0') {
969 result = CFStringCreateWithCStringNoCopy(NULL, languageName, kCFStringEncodingASCII, kCFAllocatorNull);
970 }
971 }
972 return result;
973}
974
975static CFStringRef _CFBundleCopyLanguageAbbreviationForLocalization(CFStringRef localizationName) {
976 CFStringRef result = NULL;
977 SInt32 languageCode = _CFBundleGetLanguageCodeForLocalization(localizationName);
978 if (languageCode >= 0) {
979 result = _CFBundleCopyLanguageAbbreviationForLanguageCode(languageCode);
980 } else {
981 CFIndex length = CFStringGetLength(localizationName);
982 if (length == LANGUAGE_ABBREVIATION_LENGTH - 1 || (length > LANGUAGE_ABBREVIATION_LENGTH - 1 && CFStringGetCharacterAtIndex(localizationName, LANGUAGE_ABBREVIATION_LENGTH - 1) == '_')) {
983 result = CFStringCreateWithSubstring(NULL, localizationName, CFRangeMake(0, LANGUAGE_ABBREVIATION_LENGTH - 1));
984 }
985 }
986 return result;
987}
988
989static CFStringRef _CFBundleCopyLanguageNameForLocalization(CFStringRef localizationName) {
990 CFStringRef result = NULL;
991 SInt32 languageCode = _CFBundleGetLanguageCodeForLocalization(localizationName);
992 if (languageCode >= 0) {
993 result = _CFBundleCopyLanguageNameForLanguageCode(languageCode);
994 } else {
995 result = CFStringCreateCopy(NULL, localizationName);
996 }
997 return result;
998}
999
1000static SInt32 _CFBundleGetLanguageCodeForRegionCode(SInt32 regionCode) {
1001 SInt32 result = -1, i;
1002 if (52 == regionCode) { // hack for mixed-up Chinese language codes
1003 result = 33;
1004 } else if (0 <= regionCode && regionCode < NUM_LOCALE_ABBREVIATIONS) {
1005 const char *localeAbbreviation = __CFBundleLocaleAbbreviationsArray + regionCode * LOCALE_ABBREVIATION_LENGTH;
1006 if (localeAbbreviation != NULL && *localeAbbreviation != '\0') {
1007 for (i = 0; -1 == result && i < NUM_LANGUAGE_ABBREVIATIONS * LANGUAGE_ABBREVIATION_LENGTH; i += LANGUAGE_ABBREVIATION_LENGTH) {
1008 if (localeAbbreviation[0] == *(__CFBundleLanguageAbbreviationsArray + i + 0) && localeAbbreviation[1] == *(__CFBundleLanguageAbbreviationsArray + i + 1)) result = i / LANGUAGE_ABBREVIATION_LENGTH;
1009 }
1010 }
1011 }
1012 return result;
1013}
1014
1015static SInt32 _CFBundleGetRegionCodeForLanguageCode(SInt32 languageCode) {
1016 SInt32 result = -1, i;
1017 if (19 == languageCode) { // hack for mixed-up Chinese language codes
1018 result = 53;
1019 } else if (0 <= languageCode && languageCode < NUM_LANGUAGE_ABBREVIATIONS) {
1020 const char *languageAbbreviation = __CFBundleLanguageAbbreviationsArray + languageCode * LANGUAGE_ABBREVIATION_LENGTH;
1021 if (languageAbbreviation != NULL && *languageAbbreviation != '\0') {
1022 for (i = 0; -1 == result && i < NUM_LOCALE_ABBREVIATIONS * LOCALE_ABBREVIATION_LENGTH; i += LOCALE_ABBREVIATION_LENGTH) {
1023 if (*(__CFBundleLocaleAbbreviationsArray + i + 0) == languageAbbreviation[0] && *(__CFBundleLocaleAbbreviationsArray + i + 1) == languageAbbreviation[1]) result = i / LOCALE_ABBREVIATION_LENGTH;
1024 }
1025 }
1026 }
1027 return result;
1028}
1029
1030static SInt32 _CFBundleGetRegionCodeForLocalization(CFStringRef localizationName) {
1031 SInt32 result = -1, i;
1032 char buff[LOCALE_ABBREVIATION_LENGTH];
1033 CFIndex length = CFStringGetLength(localizationName);
1034 if ((length >= LANGUAGE_ABBREVIATION_LENGTH - 1) && (length <= LOCALE_ABBREVIATION_LENGTH - 1) && CFStringGetCString(localizationName, buff, LOCALE_ABBREVIATION_LENGTH, kCFStringEncodingASCII)) {
1035 buff[LOCALE_ABBREVIATION_LENGTH - 1] = '\0';
1036 for (i = 0; -1 == result && i < NUM_LOCALE_ABBREVIATIONS * LOCALE_ABBREVIATION_LENGTH; i += LOCALE_ABBREVIATION_LENGTH) {
1037 if (0 == strcmp(buff, __CFBundleLocaleAbbreviationsArray + i)) result = i / LOCALE_ABBREVIATION_LENGTH;
1038 }
1039 }
1040 if (-1 == result) {
1041 SInt32 languageCode = _CFBundleGetLanguageCodeForLocalization(localizationName);
1042 result = _CFBundleGetRegionCodeForLanguageCode(languageCode);
1043 }
1044 return result;
1045}
1046
1047static CFStringRef _CFBundleCopyLocaleAbbreviationForRegionCode(SInt32 regionCode) {
1048 CFStringRef result = NULL;
1049 if (0 <= regionCode && regionCode < NUM_LOCALE_ABBREVIATIONS) {
1050 const char *localeAbbreviation = __CFBundleLocaleAbbreviationsArray + regionCode * LOCALE_ABBREVIATION_LENGTH;
1051 if (localeAbbreviation != NULL && *localeAbbreviation != '\0') {
1052 result = CFStringCreateWithCStringNoCopy(NULL, localeAbbreviation, kCFStringEncodingASCII, kCFAllocatorNull);
1053 }
1054 }
1055 return result;
1056}
1057
1058Boolean CFBundleGetLocalizationInfoForLocalization(CFStringRef localizationName, SInt32 *languageCode, SInt32 *regionCode, SInt32 *scriptCode, CFStringEncoding *stringEncoding) {
1059 SInt32 language = -1, region = -1, script = 0;
1060 CFStringEncoding encoding = kCFStringEncodingMacRoman;
1061 if (localizationName) {
1062 language = _CFBundleGetLanguageCodeForLocalization(localizationName);
1063 region = _CFBundleGetRegionCodeForLocalization(localizationName);
1064 } else {
1065 _CFBundleGetLanguageAndRegionCodes(&language, &region);
1066 }
1067 if ((language < 0 || language > (int)(sizeof(__CFBundleScriptCodesArray)/sizeof(SInt32))) && region != -1) language = _CFBundleGetLanguageCodeForRegionCode(region);
1068 if (region == -1 && language != -1) region = _CFBundleGetRegionCodeForLanguageCode(language);
1069 if (language >= 0 && language < (int)(sizeof(__CFBundleScriptCodesArray)/sizeof(SInt32))) {
1070 script = __CFBundleScriptCodesArray[language];
1071 }
1072 if (language >= 0 && language < (int)(sizeof(__CFBundleStringEncodingsArray)/sizeof(CFStringEncoding))) {
1073 encoding = __CFBundleStringEncodingsArray[language];
1074 }
1075 if (languageCode) *languageCode = language;
1076 if (regionCode) *regionCode = region;
1077 if (scriptCode) *scriptCode = script;
1078 if (stringEncoding) *stringEncoding = encoding;
1079 return (language != -1 || region != -1);
1080}
1081
1082CFStringRef CFBundleCopyLocalizationForLocalizationInfo(SInt32 languageCode, SInt32 regionCode, SInt32 scriptCode, CFStringEncoding stringEncoding) {
1083 CFStringRef localizationName = NULL;
1084 if (!localizationName) {
1085 localizationName = _CFBundleCopyLocaleAbbreviationForRegionCode(regionCode);
1086 }
1087 if (!localizationName) {
1088 localizationName = _CFBundleCopyLanguageAbbreviationForLanguageCode(languageCode);
1089 }
1090 if (!localizationName) {
1091 SInt32 language = -1, scriptLanguage = -1, encodingLanguage = -1;
1092 unsigned int i;
1093 for (i = 0; language == -1 && i < (sizeof(__CFBundleScriptCodesArray)/sizeof(SInt32)); i++) {
1094 if (__CFBundleScriptCodesArray[i] == scriptCode && __CFBundleStringEncodingsArray[i] == stringEncoding) language = i;
1095 }
1096 for (i = 0; scriptLanguage == -1 && i < (sizeof(__CFBundleScriptCodesArray)/sizeof(SInt32)); i++) {
1097 if (__CFBundleScriptCodesArray[i] == scriptCode) scriptLanguage = i;
1098 }
1099 for (i = 0; encodingLanguage == -1 && i < (sizeof(__CFBundleStringEncodingsArray)/sizeof(CFStringEncoding)); i++) {
1100 if (__CFBundleStringEncodingsArray[i] == stringEncoding) encodingLanguage = i;
1101 }
1102 localizationName = _CFBundleCopyLanguageAbbreviationForLanguageCode(language);
1103 if (!localizationName) localizationName = _CFBundleCopyLanguageAbbreviationForLanguageCode(encodingLanguage);
1104 if (!localizationName) localizationName = _CFBundleCopyLanguageAbbreviationForLanguageCode(scriptLanguage);
1105 }
1106 return localizationName;
1107}
1108
1109extern void *__CFAppleLanguages;
1110
1111__private_extern__ CFArrayRef _CFBundleCopyUserLanguages(Boolean useBackstops) {
1112 CFArrayRef result = NULL;
1113 static CFArrayRef userLanguages = NULL;
1114 static Boolean didit = false;
1115 CFArrayRef preferencesArray = NULL;
1116 // This is a temporary solution, until the argument domain is moved down into CFPreferences
1117 __CFSpinLock(&CFBundleResourceGlobalDataLock);
1118 if (!didit) {
1119 if (__CFAppleLanguages) {
1120 CFDataRef data;
1121 CFIndex length = strlen(__CFAppleLanguages);
1122 if (length > 0) {
1123 data = CFDataCreateWithBytesNoCopy(NULL, __CFAppleLanguages, length, kCFAllocatorNull);
1124 if (data) {
1125__CFSetNastyFile(CFSTR("<plist command-line argument>"));
1126 userLanguages = CFPropertyListCreateFromXMLData(NULL, data, kCFPropertyListImmutable, NULL);
1127 CFRelease(data);
1128 }
1129 }
1130 }
1131 if (!userLanguages && preferencesArray) userLanguages = CFRetain(preferencesArray);
1132 { // could perhaps read out of LANG environment variable
1133 CFStringRef english = CFSTR("English");
1134 if (!userLanguages) userLanguages = CFArrayCreate(kCFAllocatorDefault, (const void **)&english, 1, &kCFTypeArrayCallBacks);
1135 }
1136 if (userLanguages && CFGetTypeID(userLanguages) != CFArrayGetTypeID()) {
1137 CFRelease(userLanguages);
1138 userLanguages = NULL;
1139 }
1140 didit = true;
1141 }
1142 __CFSpinUnlock(&CFBundleResourceGlobalDataLock);
1143 if (preferencesArray) CFRelease(preferencesArray);
1144 if (!result && userLanguages) result = CFRetain(userLanguages);
1145 return result;
1146}
1147
1148CF_EXPORT void _CFBundleGetLanguageAndRegionCodes(SInt32 *languageCode, SInt32 *regionCode) {
1149 // an attempt to answer the question, "what language are we running in?"
1150 // note that the question cannot be answered fully since it may depend on the bundle
1151 SInt32 language = -1, region = -1;
1152 CFBundleRef mainBundle = CFBundleGetMainBundle();
1153 CFArrayRef languages = NULL;
1154 CFStringRef localizationName = NULL;
1155 if (mainBundle) {
1156 languages = _CFBundleGetLanguageSearchList(mainBundle);
1157 if (languages) CFRetain(languages);
1158 }
1159 if (!languages) languages = _CFBundleCopyUserLanguages(false);
1160 if (languages && (CFArrayGetCount(languages) > 0)) {
1161 localizationName = CFArrayGetValueAtIndex(languages, 0);
1162 language = _CFBundleGetLanguageCodeForLocalization(localizationName);
1163 region = _CFBundleGetRegionCodeForLocalization(localizationName);
1164 } else {
1165 language = 0;
1166 region = 0;
1167 }
1168 if (language == -1 && region != -1) language = _CFBundleGetLanguageCodeForRegionCode(region);
1169 if (region == -1 && language != -1) region = _CFBundleGetRegionCodeForLanguageCode(language);
1170 if (languages) CFRelease(languages);
1171 if (languageCode) *languageCode = language;
1172 if (regionCode) *regionCode = region;
1173}
1174
1175static Boolean _CFBundleTryOnePreferredLprojNameInDirectory(CFAllocatorRef alloc, UniChar *pathUniChars, CFIndex pathLen, uint8_t version, CFDictionaryRef infoDict, CFStringRef curLangStr, CFMutableArrayRef lprojNames) {
1176 CFIndex curLangLen = CFStringGetLength(curLangStr);
1177 UniChar curLangUniChars[255];
1178 CFIndex savedPathLen;
1179 CFStringRef languageAbbreviation = _CFBundleCopyLanguageAbbreviationForLocalization(curLangStr), languageName = _CFBundleCopyLanguageNameForLocalization(curLangStr);
1180 Boolean foundOne = false;
1181 CFArrayRef predefinedLocalizations = NULL;
1182 CFRange predefinedLocalizationsRange;
1183 CFMutableStringRef cheapStr, tmpString;
1184#if USE_GETDIRENTRIES
1185 CFArrayRef directoryContents;
1186 CFRange directoryContentsRange;
1187#else
1188 Boolean isDir = false;
1189#endif
1190
1191 // both of these used for temp string operations, for slightly
1192 // different purposes, where each type is appropriate
1193 cheapStr = CFStringCreateMutable(alloc, 0);
1194 _CFStrSetDesiredCapacity(cheapStr, CFMaxPathSize);
1195 tmpString = CFStringCreateMutableWithExternalCharactersNoCopy(kCFAllocatorSystemDefault, NULL, 0, 0, kCFAllocatorNull);
1196
1197#if USE_GETDIRENTRIES
1198 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars, pathLen, pathLen);
1199 CFStringReplaceAll(cheapStr, tmpString);
1200 directoryContents = _CFBundleCopyDirectoryContentsAtPath(cheapStr, true);
1201 directoryContentsRange = CFRangeMake(0, CFArrayGetCount(directoryContents));
1202#endif
1203
1204 if (infoDict) {
1205 predefinedLocalizations = CFDictionaryGetValue(infoDict, kCFBundleLocalizationsKey);
1206 if (predefinedLocalizations != NULL && CFGetTypeID(predefinedLocalizations) != CFArrayGetTypeID()) {
1207 predefinedLocalizations = NULL;
1208 CFDictionaryRemoveValue((CFMutableDictionaryRef)infoDict, kCFBundleLocalizationsKey);
1209 }
1210 }
1211 predefinedLocalizationsRange = CFRangeMake(0, predefinedLocalizations ? CFArrayGetCount(predefinedLocalizations) : 0);
1212
1213 CFStringGetCharacters(curLangStr, CFRangeMake(0, curLangLen), curLangUniChars);
1214 savedPathLen = pathLen;
1215 _CFAppendPathComponent(pathUniChars, &pathLen, CFMaxPathSize, curLangUniChars, curLangLen);
1216 _CFAppendPathExtension(pathUniChars, &pathLen, CFMaxPathSize, _LprojUniChars, _LprojLen);
1217#if USE_GETDIRENTRIES
1218 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars + savedPathLen + 1, pathLen - savedPathLen - 1, pathLen - savedPathLen - 1);
1219 CFStringReplaceAll(cheapStr, tmpString);
1220 if ((predefinedLocalizations && CFArrayContainsValue(predefinedLocalizations, predefinedLocalizationsRange, curLangStr)) || (version != 4 && CFArrayContainsValue(directoryContents, directoryContentsRange, cheapStr))) {
1221#else
1222 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars, pathLen, pathLen);
1223 CFStringReplaceAll(cheapStr, tmpString);
1224 if ((predefinedLocalizations && CFArrayContainsValue(predefinedLocalizations, predefinedLocalizationsRange, curLangStr)) || (version != 4 && _CFIsResourceAtPath(cheapStr, &isDir) && isDir)) {
1225#endif
1226 // We found one.
1227 CFArrayAppendValue(lprojNames, curLangStr);
1228 foundOne = true;
1229 }
1230 // Now, if the curLangStr was a region name, and we can map it to a language name, try that too.
1231 if (languageAbbreviation && !CFEqual(curLangStr, languageAbbreviation)) {
1232 curLangLen = CFStringGetLength(languageAbbreviation);
1233 CFStringGetCharacters(languageAbbreviation, CFRangeMake(0, curLangLen), curLangUniChars);
1234 pathLen = savedPathLen;
1235 _CFAppendPathComponent(pathUniChars, &pathLen, CFMaxPathSize, curLangUniChars, curLangLen);
1236 _CFAppendPathExtension(pathUniChars, &pathLen, CFMaxPathSize, _LprojUniChars, _LprojLen);
1237#if USE_GETDIRENTRIES
1238 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars + savedPathLen + 1, pathLen - savedPathLen - 1, pathLen - savedPathLen - 1);
1239 CFStringReplaceAll(cheapStr, tmpString);
1240 if ((predefinedLocalizations && CFArrayContainsValue(predefinedLocalizations, predefinedLocalizationsRange, languageAbbreviation)) || (version != 4 && CFArrayContainsValue(directoryContents, directoryContentsRange, cheapStr))) {
1241#else
1242 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars, pathLen, pathLen);
1243 CFStringReplaceAll(cheapStr, tmpString);
1244 if ((predefinedLocalizations && CFArrayContainsValue(predefinedLocalizations, predefinedLocalizationsRange, languageAbbreviation)) || (version != 4 && _CFIsResourceAtPath(cheapStr, &isDir) && isDir)) {
1245#endif
1246 // We found one.
1247 CFArrayAppendValue(lprojNames, languageAbbreviation);
1248 foundOne = true;
1249 }
1250 }
1251 if (languageName && !CFEqual(curLangStr, languageName)) {
1252 curLangLen = CFStringGetLength(languageName);
1253 CFStringGetCharacters(languageName, CFRangeMake(0, curLangLen), curLangUniChars);
1254 pathLen = savedPathLen;
1255 _CFAppendPathComponent(pathUniChars, &pathLen, CFMaxPathSize, curLangUniChars, curLangLen);
1256 _CFAppendPathExtension(pathUniChars, &pathLen, CFMaxPathSize, _LprojUniChars, _LprojLen);
1257#if USE_GETDIRENTRIES
1258 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars + savedPathLen + 1, pathLen - savedPathLen - 1, pathLen - savedPathLen - 1);
1259 CFStringReplaceAll(cheapStr, tmpString);
1260 if ((predefinedLocalizations && CFArrayContainsValue(predefinedLocalizations, predefinedLocalizationsRange, languageName)) || (version != 4 && CFArrayContainsValue(directoryContents, directoryContentsRange, cheapStr))) {
1261#else
1262 CFStringSetExternalCharactersNoCopy(tmpString, pathUniChars, pathLen, pathLen);
1263 CFStringReplaceAll(cheapStr, tmpString);
1264 if ((predefinedLocalizations && CFArrayContainsValue(predefinedLocalizations, predefinedLocalizationsRange, languageName)) || (version != 4 && _CFIsResourceAtPath(cheapStr, &isDir) && isDir)) {
1265#endif
1266 // We found one.
1267 CFArrayAppendValue(lprojNames, languageName);
1268 foundOne = true;
1269 }
1270 }
1271
1272 CFRelease(cheapStr);
1273 CFRelease(tmpString);
1274 if (languageAbbreviation) CFRelease(languageAbbreviation);
1275 if (languageName) CFRelease(languageName);
1276#if USE_GETDIRENTRIES
1277 CFRelease(directoryContents);
1278#endif
1279
1280 return foundOne;
1281}
1282
1283static Boolean CFBundleAllowMixedLocalizations(void) {
1284 static Boolean allowMixed = false, examinedMain = false;
1285 if (!examinedMain) {
1286 CFBundleRef mainBundle = CFBundleGetMainBundle();
1287 CFDictionaryRef infoDict = mainBundle ? CFBundleGetInfoDictionary(mainBundle) : NULL;
1288 CFTypeRef allowMixedValue = infoDict ? CFDictionaryGetValue(infoDict, _kCFBundleAllowMixedLocalizationsKey) : NULL;
1289 if (allowMixedValue) {
1290 CFTypeID typeID = CFGetTypeID(allowMixedValue);
1291 if (typeID == CFBooleanGetTypeID()) {
1292 allowMixed = CFBooleanGetValue((CFBooleanRef)allowMixedValue);
1293 } else if (typeID == CFStringGetTypeID()) {
1294 allowMixed = (CFStringCompare((CFStringRef)allowMixedValue, CFSTR("true"), kCFCompareCaseInsensitive) == kCFCompareEqualTo || CFStringCompare((CFStringRef)allowMixedValue, CFSTR("YES"), kCFCompareCaseInsensitive) == kCFCompareEqualTo);
1295 } else if (typeID == CFNumberGetTypeID()) {
1296 SInt32 val = 0;
1297 if (CFNumberGetValue((CFNumberRef)allowMixedValue, kCFNumberSInt32Type, &val)) allowMixed = (val != 0);
1298 }
1299 }
1300 examinedMain = true;
1301 }
1302 return allowMixed;
1303}
1304
1305__private_extern__ void _CFBundleAddPreferredLprojNamesInDirectory(CFAllocatorRef alloc, CFURLRef bundleURL, uint8_t version, CFDictionaryRef infoDict, CFMutableArrayRef lprojNames, CFStringRef devLang) {
1306 // This function will add zero, one or two elements to the lprojNames array.
1307 // It examines the users preferred language list and the lproj directories inside the bundle directory. It picks the lproj directory that is highest on the users list.
1308 // The users list can contain region names (like "en_US" for US English). In this case, if the region lproj exists, it will be added, and, if the region's associated language lproj exists that will be added.
1309 CFURLRef resourcesURL = _CFBundleCopyResourcesDirectoryURLInDirectory(alloc, bundleURL, version);
1310 CFURLRef absoluteURL;
1311 CFIndex idx;
1312 CFIndex count;
1313 CFStringRef resourcesPath;
1314 UniChar pathUniChars[CFMaxPathSize];
1315 CFIndex pathLen;
1316 CFStringRef curLangStr;
1317 Boolean foundOne = false;
1318
1319 CFArrayRef userLanguages;
1320
1321 // Init the one-time-only unichar buffers.
1322 _CFEnsureStaticBuffersInited();
1323
1324 // Get the path to the resources and extract into a buffer.
1325 absoluteURL = CFURLCopyAbsoluteURL(resourcesURL);
1326 resourcesPath = CFURLCopyFileSystemPath(absoluteURL, PLATFORM_PATH_STYLE);
1327 CFRelease(absoluteURL);
1328 pathLen = CFStringGetLength(resourcesPath);
1329 CFStringGetCharacters(resourcesPath, CFRangeMake(0, pathLen), pathUniChars);
1330 CFRelease(resourcesURL);
1331 CFRelease(resourcesPath);
1332
1333 // First check the main bundle.
1334 if (!CFBundleAllowMixedLocalizations()) {
1335 CFBundleRef mainBundle = CFBundleGetMainBundle();
1336 if (mainBundle) {
1337 CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);
1338 if (!CFEqual(bundleURL, mainBundleURL)) {
1339 // If there is a main bundle, and it isn't this one, try to use the language it prefers.
1340 CFArrayRef mainBundleLangs = _CFBundleGetLanguageSearchList(mainBundle);
1341 if (mainBundleLangs && (CFArrayGetCount(mainBundleLangs) > 0)) {
1342 curLangStr = CFArrayGetValueAtIndex(mainBundleLangs, 0);
1343 foundOne = _CFBundleTryOnePreferredLprojNameInDirectory(alloc, pathUniChars, pathLen, version, infoDict, curLangStr, lprojNames);
1344 }
1345 }
1346 CFRelease(mainBundleURL);
1347 }
1348 }
1349
1350 if (!foundOne) {
1351 // If we didn't find the main bundle's preferred language, look at the users' prefs again and find the best one.
1352 userLanguages = _CFBundleCopyUserLanguages(true);
1353 count = (userLanguages ? CFArrayGetCount(userLanguages) : 0);
1354 for (idx = 0; !foundOne && idx < count; idx++) {
1355 curLangStr = CFArrayGetValueAtIndex(userLanguages, idx);
1356 foundOne = _CFBundleTryOnePreferredLprojNameInDirectory(alloc, pathUniChars, pathLen, version, infoDict, curLangStr, lprojNames);
1357 }
1358 // use development region and U.S. English as backstops
1359 if (!foundOne && devLang != NULL) {
1360 foundOne = _CFBundleTryOnePreferredLprojNameInDirectory(alloc, pathUniChars, pathLen, version, infoDict, devLang, lprojNames);
1361 }
1362 if (!foundOne) {
1363 foundOne = _CFBundleTryOnePreferredLprojNameInDirectory(alloc, pathUniChars, pathLen, version, infoDict, CFSTR("en_US"), lprojNames);
1364 }
1365 if (userLanguages != NULL) {
1366 CFRelease(userLanguages);
1367 }
1368 }
1369}
1370
1371static Boolean _CFBundleTryOnePreferredLprojNameInArray(CFArrayRef array, CFStringRef curLangStr, CFMutableArrayRef lprojNames) {
1372 Boolean foundOne = false;
1373 CFRange range = CFRangeMake(0, CFArrayGetCount(array));
1374 CFStringRef languageAbbreviation = _CFBundleCopyLanguageAbbreviationForLocalization(curLangStr), languageName = _CFBundleCopyLanguageNameForLocalization(curLangStr);
1375
1376 if (CFArrayContainsValue(array, range, curLangStr)) {
1377 // We found one.
1378 CFArrayAppendValue(lprojNames, curLangStr);
1379 foundOne = true;
1380 }
1381 if (languageAbbreviation && !CFEqual(curLangStr, languageAbbreviation)) {
1382 if (CFArrayContainsValue(array, range, languageAbbreviation)) {
1383 // We found one.
1384 CFArrayAppendValue(lprojNames, languageAbbreviation);
1385 foundOne = true;
1386 }
1387 }
1388 if (languageName && !CFEqual(curLangStr, languageName)) {
1389 if (CFArrayContainsValue(array, range, languageName)) {
1390 // We found one.
1391 CFArrayAppendValue(lprojNames, languageName);
1392 foundOne = true;
1393 }
1394 }
1395
1396 if (languageAbbreviation) CFRelease(languageAbbreviation);
1397 if (languageName) CFRelease(languageName);
1398
1399 return foundOne;
1400}
1401
1402static CFArrayRef _CFBundleCopyLocalizationsForPreferences(CFArrayRef locArray, CFArrayRef prefArray, Boolean considerMain) {
1403 CFMutableArrayRef lprojNames = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
1404 Boolean foundOne = false, releasePrefArray = false;
1405 CFIndex idx, count;
1406
1407 if (considerMain && !CFBundleAllowMixedLocalizations()) {
1408 CFBundleRef mainBundle = CFBundleGetMainBundle();
1409 if (mainBundle) {
1410 // If there is a main bundle, try to use the language it prefers.
1411 CFArrayRef mainBundleLangs = _CFBundleGetLanguageSearchList(mainBundle);
1412 if (mainBundleLangs && (CFArrayGetCount(mainBundleLangs) > 0)) {
1413 foundOne = _CFBundleTryOnePreferredLprojNameInArray(locArray, CFArrayGetValueAtIndex(mainBundleLangs, 0), lprojNames);
1414 }
1415 }
1416 }
1417 if (!foundOne) {
1418 if (!prefArray) {
1419 prefArray = _CFBundleCopyUserLanguages(true);
1420 if (prefArray) releasePrefArray = true;
1421 }
1422 count = (prefArray ? CFArrayGetCount(prefArray) : 0);
1423 for (idx = 0; !foundOne && idx < count; idx++) {
1424 foundOne = _CFBundleTryOnePreferredLprojNameInArray(locArray, CFArrayGetValueAtIndex(prefArray, idx), lprojNames);
1425 }
1426 // use U.S. English as backstop
1427 if (!foundOne) {
1428 foundOne = _CFBundleTryOnePreferredLprojNameInArray(locArray, CFSTR("en_US"), lprojNames);
1429 }
1430 // use random entry as backstop
1431 if (!foundOne && CFArrayGetCount(lprojNames) > 0) {
1432 foundOne = _CFBundleTryOnePreferredLprojNameInArray(locArray, CFArrayGetValueAtIndex(locArray, 0), lprojNames);
1433 }
1434 }
1435 if (CFArrayGetCount(lprojNames) == 0) {
1436 // Total backstop behavior to avoid having an empty array.
1437 CFArrayAppendValue(lprojNames, CFSTR("en"));
1438 }
1439 if (releasePrefArray) {
1440 CFRelease(prefArray);
1441 }
1442 return lprojNames;
1443}
1444
1445CF_EXPORT CFArrayRef CFBundleCopyLocalizationsForPreferences(CFArrayRef locArray, CFArrayRef prefArray) {return _CFBundleCopyLocalizationsForPreferences(locArray, prefArray, false);}
1446
1447CF_EXPORT CFArrayRef CFBundleCopyPreferredLocalizationsFromArray(CFArrayRef locArray) {return _CFBundleCopyLocalizationsForPreferences(locArray, NULL, true);}
1448
1449__private_extern__ CFArrayRef _CFBundleCopyLanguageSearchListInDirectory(CFAllocatorRef alloc, CFURLRef url, uint8_t *version) {
1450 CFMutableArrayRef langs = CFArrayCreateMutable(alloc, 0, &kCFTypeArrayCallBacks);
1451 uint8_t localVersion = 0;
1452 CFDictionaryRef infoDict = _CFBundleCopyInfoDictionaryInDirectory(alloc, url, &localVersion);
1453 CFStringRef devLang = NULL;
1454 if (infoDict != NULL) {
1455 devLang = CFDictionaryGetValue(infoDict, kCFBundleDevelopmentRegionKey);
1456 }
1457 if (devLang != NULL && (CFGetTypeID(devLang) != CFStringGetTypeID() || CFStringGetLength(devLang) == 0)) devLang = NULL;
1458
1459 _CFBundleAddPreferredLprojNamesInDirectory(alloc, url, localVersion, infoDict, langs, devLang);
1460
1461 if (devLang != NULL && CFArrayGetFirstIndexOfValue(langs, CFRangeMake(0, CFArrayGetCount(langs)), devLang) < 0) {
1462 CFArrayAppendValue(langs, devLang);
1463 }
1464 if (CFArrayGetCount(langs) == 0) {
1465 // Total backstop behavior to avoid having an empty array.
1466 CFArrayAppendValue(langs, CFSTR("en"));
1467 }
1468 if (infoDict != NULL) {
1469 CFRelease(infoDict);
1470 }
1471 if (version) {
1472 *version = localVersion;
1473 }
1474 return langs;
1475}
1476
1477CF_EXPORT Boolean _CFBundleURLLooksLikeBundle(CFURLRef url) {
1478 Boolean result = false;
1479 CFBundleRef bundle = _CFBundleCreateIfLooksLikeBundle(NULL, url);
1480 if (bundle) {
1481 result = true;
1482 CFRelease(bundle);
1483 }
1484 return result;
1485}
1486
1487// Note that subDirName is expected to be the string for a URL
1488CF_INLINE Boolean _CFBundleURLHasSubDir(CFURLRef url, CFStringRef subDirName) {
1489 CFURLRef dirURL;
1490 Boolean isDir, result = false;
1491
1492 dirURL = CFURLCreateWithString(NULL, subDirName, url);
1493 if (dirURL != NULL) {
1494 if (_CFIsResourceAtURL(dirURL, &isDir) && isDir) {
1495 result = true;
1496 }
1497 CFRelease(dirURL);
1498 }
1499 return result;
1500}
1501
1502__private_extern__ Boolean _CFBundleURLLooksLikeBundleVersion(CFURLRef url, uint8_t *version) {
1503 Boolean result = false;
1504 uint8_t localVersion = 0;
1505
1506 // check for existence of "Resources" or "Contents" or "Support Files"
1507 // but check for the most likely one first
1508 // version 0: old-style "Resources" bundles
1509 // version 1: obsolete "Support Files" bundles
1510 // version 2: modern "Contents" bundles
1511 // version 3: none of the above (see below)
1512 // version 4: not a bundle (for main bundle only)
1513 if (CFStringHasSuffix(CFURLGetString(url), CFSTR(".framework/"))) {
1514 if (_CFBundleURLHasSubDir(url, _CFBundleResourcesURLFromBase0)) {
1515 result = true;
1516 localVersion = 0;
1517 } else if (_CFBundleURLHasSubDir(url, _CFBundleSupportFilesURLFromBase2)) {
1518 result = true;
1519 localVersion = 2;
1520 } else if (_CFBundleURLHasSubDir(url, _CFBundleSupportFilesURLFromBase1)) {
1521 result = true;
1522 localVersion = 1;
1523 }
1524 } else {
1525 if (_CFBundleURLHasSubDir(url, _CFBundleSupportFilesURLFromBase2)) {
1526 result = true;
1527 localVersion = 2;
1528 } else if (_CFBundleURLHasSubDir(url, _CFBundleResourcesURLFromBase0)) {
1529 result = true;
1530 localVersion = 0;
1531 } else if (_CFBundleURLHasSubDir(url, _CFBundleSupportFilesURLFromBase1)) {
1532 result = true;
1533 localVersion = 1;
1534 }
1535 }
1536 if (result && version) *version = localVersion;
1537 return result;
1538}
1539
1540__private_extern__ CFDictionaryRef _CFBundleCopyInfoDictionaryInDirectory(CFAllocatorRef alloc, CFURLRef url, uint8_t *version) {
1541 CFDictionaryRef dict = NULL;
1542 char buff[CFMaxPathSize];
1543 uint8_t localVersion = 0;
1544
1545 if (CFURLGetFileSystemRepresentation(url, true, buff, CFMaxPathSize)) {
1546 CFURLRef newURL = CFURLCreateFromFileSystemRepresentation(alloc, buff, strlen(buff), true);
1547 if (NULL == newURL) newURL = CFRetain(url);
1548
1549 if (!_CFBundleURLLooksLikeBundleVersion(newURL, &localVersion)) {
1550 // version 3 is for flattened pseudo-bundles with no Contents, Support Files, or Resources directories
1551 localVersion = 3;
1552 }
1553 dict = _CFBundleCopyInfoDictionaryInDirectoryWithVersion(alloc, newURL, localVersion);
1554 CFRelease(newURL);
1555 }
1556 if (version) *version = localVersion;
1557 return dict;
1558}
1559
1560__private_extern__ CFDictionaryRef _CFBundleCopyInfoDictionaryInDirectoryWithVersion(CFAllocatorRef alloc, CFURLRef url, uint8_t version) {
1561 CFDictionaryRef result = NULL;
1562 if (url != NULL) {
1563 CFURLRef infoURL = NULL;
1564 CFDataRef infoData = NULL;
1565 UniChar buff[CFMaxPathSize];
1566 CFIndex len;
1567 CFMutableStringRef cheapStr;
1568 CFStringRef infoURLFromBaseNoExtension = _CFBundleInfoURLFromBaseNoExtension0, infoURLFromBase = _CFBundleInfoURLFromBase0;
1569 Boolean tryPlatformSpecific = true, tryGlobal = true;
1570#if USE_GETDIRENTRIES
1571 CFArrayRef directoryContents = NULL;
1572 CFRange directoryContentsRange = CFRangeMake(0, 0);
1573#endif
1574
1575 _CFEnsureStaticBuffersInited();
1576
1577 if (0 == version) {
1578#if USE_GETDIRENTRIES
1579 // we want to read the Resources directory anyway, so we might as well do it now
1580 CFURLRef resourcesURL = _CFBundleCopyResourcesDirectoryURLInDirectory(alloc, url, version);
1581 CFURLRef absoluteURL = CFURLCopyAbsoluteURL(resourcesURL);
1582 CFStringRef resourcesPath = CFURLCopyFileSystemPath(absoluteURL, PLATFORM_PATH_STYLE);
1583 directoryContents = _CFBundleCopyDirectoryContentsAtPath(resourcesPath, false);
1584 directoryContentsRange = CFRangeMake(0, CFArrayGetCount(directoryContents));
1585 CFRelease(resourcesPath);
1586 CFRelease(absoluteURL);
1587 CFRelease(resourcesURL);
1588#endif
1589 infoURLFromBaseNoExtension = _CFBundleInfoURLFromBaseNoExtension0;
1590 infoURLFromBase = _CFBundleInfoURLFromBase0;
1591 } else if (1 == version) {
1592 infoURLFromBaseNoExtension = _CFBundleInfoURLFromBaseNoExtension1;
1593 infoURLFromBase = _CFBundleInfoURLFromBase1;
1594 } else if (2 == version) {
1595 infoURLFromBaseNoExtension = _CFBundleInfoURLFromBaseNoExtension2;
1596 infoURLFromBase = _CFBundleInfoURLFromBase2;
1597 } else if (3 == version) {
1598 CFStringRef posixPath = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
1599 // this test is necessary to exclude the case where a bundle is spuriously created from the innards of another bundle
1600 if (posixPath) {
1601 if (!(CFStringHasSuffix(posixPath, _CFBundleSupportFilesDirectoryName1) || CFStringHasSuffix(posixPath, _CFBundleSupportFilesDirectoryName2) || CFStringHasSuffix(posixPath, _CFBundleResourcesDirectoryName))) {
1602 infoURLFromBaseNoExtension = _CFBundleInfoURLFromBaseNoExtension3;
1603 infoURLFromBase = _CFBundleInfoURLFromBase3;
1604 }
1605 CFRelease(posixPath);
1606 }
1607 }
1608
1609 len = CFStringGetLength(infoURLFromBaseNoExtension);
1610 CFStringGetCharacters(infoURLFromBaseNoExtension, CFRangeMake(0, len), buff);
1611 buff[len++] = (UniChar)'-';
1612 memmove(buff + len, _PlatformUniChars, _PlatformLen * sizeof(UniChar));
1613 len += _PlatformLen;
1614 _CFAppendPathExtension(buff, &len, CFMaxPathSize, _InfoExtensionUniChars, _InfoExtensionLen);
1615 cheapStr = CFStringCreateMutable(alloc, 0);
1616 CFStringAppendCharacters(cheapStr, buff, len);
1617 infoURL = CFURLCreateWithString(alloc, cheapStr, url);
1618#if USE_GETDIRENTRIES
1619 if (directoryContents) {
1620 CFIndex resourcesLen = CFStringGetLength(_CFBundleResourcesURLFromBase0);
1621 CFStringDelete(cheapStr, CFRangeMake(0, CFStringGetLength(cheapStr)));
1622 CFStringAppendCharacters(cheapStr, buff + resourcesLen, len - resourcesLen);
1623 tryPlatformSpecific = CFArrayContainsValue(directoryContents, directoryContentsRange, cheapStr);
1624 }
1625#endif
1626 if (tryPlatformSpecific) CFURLCreateDataAndPropertiesFromResource(alloc, infoURL, &infoData, NULL, NULL, NULL);
1627 //fprintf(stderr, "looking for ");CFShow(infoURL);if (infoData) fprintf(stderr, "found it\n");
1628 CFRelease(cheapStr);
1629 if (!infoData) {
1630 // Check for global Info.plist
1631 CFRelease(infoURL);
1632 infoURL = CFURLCreateWithString(alloc, infoURLFromBase, url);
1633#if USE_GETDIRENTRIES
1634 if (directoryContents) tryGlobal = CFArrayContainsValue(directoryContents, directoryContentsRange, _CFBundleInfoFileName);
1635#endif
1636 if (tryGlobal) CFURLCreateDataAndPropertiesFromResource(alloc, infoURL, &infoData, NULL, NULL, NULL);
1637 //fprintf(stderr, "looking for ");CFShow(infoURL);if (infoData) fprintf(stderr, "found it\n");
1638 }
1639
1640 if (infoData) {
1641 result = CFPropertyListCreateFromXMLData(alloc, infoData, kCFPropertyListMutableContainers, NULL);
1642 if (result) {
1643 if (CFDictionaryGetTypeID() == CFGetTypeID(result)) {
1644 CFDictionarySetValue((CFMutableDictionaryRef)result, _kCFBundleInfoPlistURLKey, infoURL);
1645 } else {
1646 CFRelease(result);
1647 result = NULL;
1648 }
1649 }
1650 CFRelease(infoData);
1651 }
1652 if (!result) {
1653 result = CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
1654 }
1655
1656 CFRelease(infoURL);
1657#if USE_GETDIRENTRIES
1658 if (directoryContents) CFRelease(directoryContents);
1659#endif
1660 }
1661 return result;
1662}
1663
1664static Boolean _CFBundleGetPackageInfoInDirectoryWithInfoDictionary(CFAllocatorRef alloc, CFURLRef url, CFDictionaryRef infoDict, UInt32 *packageType, UInt32 *packageCreator) {
1665 Boolean retVal = false, hasType = false, hasCreator = false, releaseInfoDict = false;
1666 CFURLRef tempURL;
1667 CFDataRef pkgInfoData = NULL;
1668
1669 // Check for a "real" new bundle
1670 tempURL = CFURLCreateWithString(alloc, _CFBundlePkgInfoURLFromBase2, url);
1671 CFURLCreateDataAndPropertiesFromResource(alloc, tempURL, &pkgInfoData, NULL, NULL, NULL);
1672 CFRelease(tempURL);
1673 if (pkgInfoData == NULL) {
1674 tempURL = CFURLCreateWithString(alloc, _CFBundlePkgInfoURLFromBase1, url);
1675 CFURLCreateDataAndPropertiesFromResource(alloc, tempURL, &pkgInfoData, NULL, NULL, NULL);
1676 CFRelease(tempURL);
1677 }
1678 if (pkgInfoData == NULL) {
1679 // Check for a "pseudo" new bundle
1680 tempURL = CFURLCreateWithString(alloc, _CFBundlePseudoPkgInfoURLFromBase, url);
1681 CFURLCreateDataAndPropertiesFromResource(alloc, tempURL, &pkgInfoData, NULL, NULL, NULL);
1682 CFRelease(tempURL);
1683 }
1684
1685 // Now, either we have a pkgInfoData or not. If not, then is it because this is a new bundle without one (do we allow this?), or is it dbecause it is an old bundle.
1686 // If we allow new bundles to not have a PkgInfo (because they already have the same data in the Info.plist), then we have to go read the info plist which makes failure expensive.
1687 // drd: So we assume that a new bundle _must_ have a PkgInfo if they have this data at all, otherwise we manufacture it from the extension.
1688
1689 if ((pkgInfoData != NULL) && (CFDataGetLength(pkgInfoData) >= (int)(sizeof(UInt32) * 2))) {
1690 UInt32 *pkgInfo = (UInt32 *)CFDataGetBytePtr(pkgInfoData);
1691
1692 if (packageType != NULL) {
1693 *packageType = CFSwapInt32BigToHost(pkgInfo[0]);
1694 }
1695 if (packageCreator != NULL) {
1696 *packageCreator = CFSwapInt32BigToHost(pkgInfo[1]);
1697 }
1698 retVal = hasType = hasCreator = true;
1699 }
1700 if (pkgInfoData != NULL) CFRelease(pkgInfoData);
1701 if (!retVal) {
1702 if (!infoDict) {
1703 infoDict = _CFBundleCopyInfoDictionaryInDirectory(alloc, url, NULL);
1704 releaseInfoDict = true;
1705 }
1706 if (infoDict) {
1707 CFStringRef typeString = CFDictionaryGetValue(infoDict, _kCFBundlePackageTypeKey), creatorString = CFDictionaryGetValue(infoDict, _kCFBundleSignatureKey);
1708 UInt32 tmp;
1709 CFIndex usedBufLen = 0;
1710 if (typeString && CFGetTypeID(typeString) == CFStringGetTypeID() && CFStringGetLength(typeString) == 4 && 4 == CFStringGetBytes(typeString, CFRangeMake(0, 4), kCFStringEncodingMacRoman, 0, false, (UInt8 *)&tmp, 4, &usedBufLen) && 4 == usedBufLen) {
1711 if (packageType != NULL) {
1712 *packageType = CFSwapInt32BigToHost(tmp);
1713 }
1714 retVal = hasType = true;
1715 }
1716 if (creatorString && CFGetTypeID(creatorString) == CFStringGetTypeID() && CFStringGetLength(creatorString) == 4 && 4 == CFStringGetBytes(creatorString, CFRangeMake(0, 4), kCFStringEncodingMacRoman, 0, false, (UInt8 *)&tmp, 4, &usedBufLen) && 4 == usedBufLen) {
1717 if (packageCreator != NULL) {
1718 *packageCreator = CFSwapInt32BigToHost(tmp);
1719 }
1720 retVal = hasCreator = true;
1721 }
1722 if (releaseInfoDict) CFRelease(infoDict);
1723 }
1724 }
1725 if (!hasType || !hasCreator) {
1726 // If this looks like a bundle then manufacture the type and creator.
1727 if (retVal || _CFBundleURLLooksLikeBundle(url)) {
1728 if (packageCreator != NULL && !hasCreator) {
1729 *packageCreator = 0x3f3f3f3f; // '????'
1730 }
1731 if (packageType != NULL && !hasType) {
1732 CFStringRef urlStr;
1733 UniChar buff[CFMaxPathSize];
1734 CFIndex strLen, startOfExtension;
1735 CFURLRef absoluteURL;
1736
1737 // Detect "app", "debug", "profile", or "framework" extensions
1738 absoluteURL = CFURLCopyAbsoluteURL(url);
1739 urlStr = CFURLCopyFileSystemPath(absoluteURL, PLATFORM_PATH_STYLE);
1740 CFRelease(absoluteURL);
1741 strLen = CFStringGetLength(urlStr);
1742 CFStringGetCharacters(urlStr, CFRangeMake(0, strLen), buff);
1743 CFRelease(urlStr);
1744 startOfExtension = _CFStartOfPathExtension(buff, strLen);
1745 if (((strLen - startOfExtension == 4) || (strLen - startOfExtension == 5)) && (buff[startOfExtension] == (UniChar)'.') && (buff[startOfExtension+1] == (UniChar)'a') && (buff[startOfExtension+2] == (UniChar)'p') && (buff[startOfExtension+3] == (UniChar)'p') && ((strLen - startOfExtension == 4) || (buff[startOfExtension+4] == (UniChar)'/'))) {
1746 // This is an app
1747 *packageType = CFSwapInt32BigToHost(0x4150504c); // 'APPL'
1748 } else if (((strLen - startOfExtension == 6) || (strLen - startOfExtension == 7)) && (buff[startOfExtension] == (UniChar)'.') && (buff[startOfExtension+1] == (UniChar)'d') && (buff[startOfExtension+2] == (UniChar)'e') && (buff[startOfExtension+3] == (UniChar)'b') && (buff[startOfExtension+4] == (UniChar)'u') && (buff[startOfExtension+5] == (UniChar)'g') && ((strLen - startOfExtension == 6) || (buff[startOfExtension+6] == (UniChar)'/'))) {
1749 // This is an app (debug version)
1750 *packageType = CFSwapInt32BigToHost(0x4150504c); // 'APPL'
1751 } else if (((strLen - startOfExtension == 8) || (strLen - startOfExtension == 9)) && (buff[startOfExtension] == (UniChar)'.') && (buff[startOfExtension+1] == (UniChar)'p') && (buff[startOfExtension+2] == (UniChar)'r') && (buff[startOfExtension+3] == (UniChar)'o') && (buff[startOfExtension+4] == (UniChar)'f') && (buff[startOfExtension+5] == (UniChar)'i') && (buff[startOfExtension+6] == (UniChar)'l') && (buff[startOfExtension+7] == (UniChar)'e') && ((strLen - startOfExtension == 8) || (buff[startOfExtension+8] == (UniChar)'/'))) {
1752 // This is an app (profile version)
1753 *packageType = CFSwapInt32BigToHost(0x4150504c); // 'APPL'
1754 } else if (((strLen - startOfExtension == 8) || (strLen - startOfExtension == 9)) && (buff[startOfExtension] == (UniChar)'.') && (buff[startOfExtension+1] == (UniChar)'s') && (buff[startOfExtension+2] == (UniChar)'e') && (buff[startOfExtension+3] == (UniChar)'r') && (buff[startOfExtension+4] == (UniChar)'v') && (buff[startOfExtension+5] == (UniChar)'i') && (buff[startOfExtension+6] == (UniChar)'c') && (buff[startOfExtension+7] == (UniChar)'e') && ((strLen - startOfExtension == 8) || (buff[startOfExtension+8] == (UniChar)'/'))) {
1755 // This is a service
1756 *packageType = CFSwapInt32BigToHost(0x4150504c); // 'APPL'
1757 } else if (((strLen - startOfExtension == 10) || (strLen - startOfExtension == 11)) && (buff[startOfExtension] == (UniChar)'.') && (buff[startOfExtension+1] == (UniChar)'f') && (buff[startOfExtension+2] == (UniChar)'r') && (buff[startOfExtension+3] == (UniChar)'a') && (buff[startOfExtension+4] == (UniChar)'m') && (buff[startOfExtension+5] == (UniChar)'e') && (buff[startOfExtension+6] == (UniChar)'w') && (buff[startOfExtension+7] == (UniChar)'o') && (buff[startOfExtension+8] == (UniChar)'r') && (buff[startOfExtension+9] == (UniChar)'k') && ((strLen - startOfExtension == 10) || (buff[startOfExtension+10] == (UniChar)'/'))) {
1758 // This is a framework
1759 *packageType = CFSwapInt32BigToHost(0x464d574b); // 'FMWK'
1760 } else {
1761 // Default to BNDL for generic bundle
1762 *packageType = CFSwapInt32BigToHost(0x424e444C); // 'BNDL'
1763 }
1764 }
1765 retVal = true;
1766 }
1767 }
1768 return retVal;
1769}
1770
1771CF_EXPORT Boolean _CFBundleGetPackageInfoInDirectory(CFAllocatorRef alloc, CFURLRef url, UInt32 *packageType, UInt32 *packageCreator) {return _CFBundleGetPackageInfoInDirectoryWithInfoDictionary(alloc, url, NULL, packageType, packageCreator);}
1772
1773CF_EXPORT void CFBundleGetPackageInfo(CFBundleRef bundle, UInt32 *packageType, UInt32 *packageCreator) {
1774 CFURLRef bundleURL = CFBundleCopyBundleURL(bundle);
1775 if (!_CFBundleGetPackageInfoInDirectoryWithInfoDictionary(CFGetAllocator(bundle), bundleURL, CFBundleGetInfoDictionary(bundle), packageType, packageCreator)) {
1776 if (packageType != NULL) {
1777 *packageType = CFSwapInt32BigToHost(0x424e444C); // 'BNDL'
1778 }
1779 if (packageCreator != NULL) {
1780 *packageCreator = 0x3f3f3f3f; // '????'
1781 }
1782 }
1783 if (bundleURL) CFRelease(bundleURL);
1784}
1785
1786CF_EXPORT Boolean CFBundleGetPackageInfoInDirectory(CFURLRef url, UInt32 *packageType, UInt32 *packageCreator) {return _CFBundleGetPackageInfoInDirectory(NULL, url, packageType, packageCreator);}
1787
1788__private_extern__ CFStringRef _CFBundleGetPlatformExecutablesSubdirectoryName(void) {
1789#if defined(__MACOS8__)
1790 return CFSTR("MacOSClassic");
1791#elif defined(__WIN32__)
1792 return CFSTR("Windows");
1793#elif defined(__MACH__)
1794 return CFSTR("MacOS");
1795#elif defined(__hpux__)
1796 return CFSTR("HPUX");
1797#elif defined(__svr4__)
1798 return CFSTR("Solaris");
1799#elif defined(__LINUX__)
1800 return CFSTR("Linux");
1801#elif defined(__FREEBSD__)
1802 return CFSTR("FreeBSD");
1803#else
1804#warning CFBundle: Unknown architecture
1805 return CFSTR("Other");
1806#endif
1807}
1808
1809__private_extern__ CFStringRef _CFBundleGetAlternatePlatformExecutablesSubdirectoryName(void) {
1810#if defined(__MACOS8__)
1811 return CFSTR("Mac OS 8");
1812#elif defined(__WIN32__)
1813 return CFSTR("WinNT");
1814#elif defined(__MACH__)
1815 return CFSTR("Mac OS X");
1816#elif defined(__hpux__)
1817 return CFSTR("HP-UX");
1818#elif defined(__svr4__)
1819 return CFSTR("Solaris");
1820#elif defined(__LINUX__)
1821 return CFSTR("Linux");
1822#elif defined(__FREEBSD__)
1823 return CFSTR("FreeBSD");
1824#else
1825#warning CFBundle: Unknown architecture
1826 return CFSTR("Other");
1827#endif
1828}
1829
1830__private_extern__ CFStringRef _CFBundleGetOtherPlatformExecutablesSubdirectoryName(void) {
1831#if defined(__MACOS8__)
1832 return CFSTR("MacOS");
1833#elif defined(__WIN32__)
1834 return CFSTR("Other");
1835#elif defined(__MACH__)
1836 return CFSTR("MacOSClassic");
1837#elif defined(__hpux__)
1838 return CFSTR("Other");
1839#elif defined(__svr4__)
1840 return CFSTR("Other");
1841#elif defined(__LINUX__)
1842 return CFSTR("Other");
1843#elif defined(__FREEBSD__)
1844 return CFSTR("Other");
1845#else
1846#warning CFBundle: Unknown architecture
1847 return CFSTR("Other");
1848#endif
1849}
1850
1851__private_extern__ CFStringRef _CFBundleGetOtherAlternatePlatformExecutablesSubdirectoryName(void) {
1852#if defined(__MACOS8__)
1853 return CFSTR("Mac OS X");
1854#elif defined(__WIN32__)
1855 return CFSTR("Other");
1856#elif defined(__MACH__)
1857 return CFSTR("Mac OS 8");
1858#elif defined(__hpux__)
1859 return CFSTR("Other");
1860#elif defined(__svr4__)
1861 return CFSTR("Other");
1862#elif defined(__LINUX__)
1863 return CFSTR("Other");
1864#elif defined(__FREEBSD__)
1865 return CFSTR("Other");
1866#else
1867#warning CFBundle: Unknown architecture
1868 return CFSTR("Other");
1869#endif
1870}
1871
1872__private_extern__ CFArrayRef _CFBundleCopyBundleRegionsArray(CFBundleRef bundle) {return CFBundleCopyBundleLocalizations(bundle);}
1873
1874CF_EXPORT CFArrayRef CFBundleCopyBundleLocalizations(CFBundleRef bundle) {
1875 CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(bundle);
1876 uint8_t version = _CFBundleLayoutVersion(bundle);
1877 CFArrayRef urls = ((version != 4) ? _CFContentsOfDirectory(CFGetAllocator(bundle), NULL, NULL, resourcesURL, CFSTR("lproj")) : NULL);
1878 CFArrayRef predefinedLocalizations = NULL;
1879 CFDictionaryRef infoDict = CFBundleGetInfoDictionary(bundle);
1880 CFMutableArrayRef result = NULL;
1881
1882 if (infoDict) {
1883 predefinedLocalizations = CFDictionaryGetValue(infoDict, kCFBundleLocalizationsKey);
1884 if (predefinedLocalizations != NULL && CFGetTypeID(predefinedLocalizations) != CFArrayGetTypeID()) {
1885 predefinedLocalizations = NULL;
1886 CFDictionaryRemoveValue((CFMutableDictionaryRef)infoDict, kCFBundleLocalizationsKey);
1887 }
1888 if (predefinedLocalizations != NULL) {
1889 CFIndex i, c = CFArrayGetCount(predefinedLocalizations);
1890 if (c > 0 && !result) {
1891 result = CFArrayCreateMutable(CFGetAllocator(bundle), 0, &kCFTypeArrayCallBacks);
1892 }
1893 for (i=0; i<c; i++) {
1894 CFArrayAppendValue(result, CFArrayGetValueAtIndex(predefinedLocalizations, i));
1895 }
1896 }
1897 }
1898
1899 if (urls) {
1900 CFIndex i, c;
1901 CFURLRef curURL, curAbsoluteURL;
1902 CFStringRef curStr, regionStr;
1903 UniChar buff[CFMaxPathSize];
1904 CFIndex strLen, startOfLastPathComponent, regionLen;
1905
1906 c = CFArrayGetCount(urls);
1907 if (c > 0 && !result) {
1908 result = CFArrayCreateMutable(CFGetAllocator(bundle), 0, &kCFTypeArrayCallBacks);
1909 }
1910 for (i = 0; i < c; i++) {
1911 curURL = CFArrayGetValueAtIndex(urls, i);
1912 curAbsoluteURL = CFURLCopyAbsoluteURL(curURL);
1913 curStr = CFURLCopyFileSystemPath(curAbsoluteURL, PLATFORM_PATH_STYLE);
1914 CFRelease(curAbsoluteURL);
1915 strLen = CFStringGetLength(curStr);
1916 CFStringGetCharacters(curStr, CFRangeMake(0, strLen), buff);
1917
1918 startOfLastPathComponent = _CFStartOfLastPathComponent(buff, strLen);
1919 regionLen = _CFLengthAfterDeletingPathExtension(&(buff[startOfLastPathComponent]), strLen - startOfLastPathComponent);
1920 regionStr = CFStringCreateWithCharacters(CFGetAllocator(bundle), &(buff[startOfLastPathComponent]), regionLen);
1921 CFArrayAppendValue(result, regionStr);
1922 CFRelease(regionStr);
1923 CFRelease(curStr);
1924 }
1925 CFRelease(urls);
1926 }
1927 if (!result) {
1928 CFStringRef developmentLocalization = CFBundleGetDevelopmentRegion(bundle);
1929 if (developmentLocalization) {
1930 result = CFArrayCreateMutable(CFGetAllocator(bundle), 0, &kCFTypeArrayCallBacks);
1931 CFArrayAppendValue(result, developmentLocalization);
1932 }
1933 }
1934 if (resourcesURL) CFRelease(resourcesURL);
1935
1936 return result;
1937}
1938
1939
1940CF_EXPORT CFDictionaryRef CFBundleCopyInfoDictionaryForURL(CFURLRef url) {
1941 CFDictionaryRef result = NULL;
1942 Boolean isDir;
1943 if (_CFIsResourceAtURL(url, &isDir)) {
1944 if (isDir) {
1945 result = _CFBundleCopyInfoDictionaryInDirectory(NULL, url, NULL);
1946 } else {
1947 result = _CFBundleCopyInfoDictionaryInExecutable(url);
1948 }
1949 }
1950 return result;
1951}
1952
1953CFArrayRef CFBundleCopyLocalizationsForURL(CFURLRef url) {
1954 CFArrayRef result = NULL;
1955 CFBundleRef bundle = CFBundleCreate(NULL, url);
1956 CFStringRef devLang = NULL;
1957 if (bundle) {
1958 result = CFBundleCopyBundleLocalizations(bundle);
1959 CFRelease(bundle);
1960 } else {
1961 CFDictionaryRef infoDict = _CFBundleCopyInfoDictionaryInExecutable(url);
1962 if (infoDict) {
1963 CFArrayRef predefinedLocalizations = CFDictionaryGetValue(infoDict, kCFBundleLocalizationsKey);
1964 if (predefinedLocalizations != NULL && CFGetTypeID(predefinedLocalizations) == CFArrayGetTypeID()) {
1965 result = CFRetain(predefinedLocalizations);
1966 }
1967 if (!result) {
1968 devLang = CFDictionaryGetValue(infoDict, kCFBundleDevelopmentRegionKey);
1969 if (devLang != NULL && (CFGetTypeID(devLang) == CFStringGetTypeID() && CFStringGetLength(devLang) > 0)) {
1970 result = CFArrayCreate(NULL, (const void **)&devLang, 1, &kCFTypeArrayCallBacks);
1971 }
1972 }
1973 CFRelease(infoDict);
1974 }
1975 }
1976 return result;
1977}
mirror of CF