![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to NXBundle.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / objc|
Return to NXBundle.m CVS log | Up to [Apple Darwin 0.x] / objc |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.0 (the 'License'). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License."
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: /* NXBundle.m
25: Copyright 1990, 1991, NeXT, Inc.
26: IPC, November 1990
27: */
28:
29: #ifndef KERNEL
30: #ifdef SHLIB
31: #import "shlib.h"
32: #endif SHLIB
33:
34:
35: #import "NXBundle.h"
36: #import "NXBundlePrivate.h"
37: #import "maptable.h"
38: #import "NXStringTable.h"
39: #import "objc-load.h"
40: #import "hashtable.h"
41: #import "objc-private.h"
42:
43: #import <sys/file.h>
44: #import <sys/dir.h>
45: #import <sys/stat.h>
46: #import <sys/types.h>
47:
48: #import <strings.h>
49:
50: static void warning(const char *format, ...) {}
51:
52: /* For the LProj cache */
53: static id bundleTable = nil;
54: static id mainBundleStringTableTable = nil;
55:
56: #define BUNDLE_SUFFIX "bundle"
57:
58: /******* Bundle ********/
59:
60: @implementation NXBundle
61:
62: static NXMapTable *classToBundle = NULL;
63:
64: static NXBundle *mainBundle = nil;
65: static NXMapTable *pathToBundle = NULL;
66:
67: - initForDirectory:(const char *)bp {
68: struct stat statInfo;
69: id bb;
70:
71: if (! pathToBundle) pathToBundle = NXCreateMapTable(NXStrValueMapPrototype, 1);
72: bb = NXMapGet(pathToBundle, bp);
73: if (bb) {
74: [self free];
75: return bb;
76: } else {
77: BOOL allOK = YES;
78:
79: if (stat(bp, &statInfo) == 0) {
80: while (allOK && (statInfo.st_mode & S_IFLNK)) {
81: char linkPath[MAXPATHLEN + 1];
82:
83: allOK = ((readlink(bp, linkPath, sizeof(linkPath)) != -1)
84: && (stat(linkPath, &statInfo) == 0));
85: }
86: allOK = allOK
87: && ((statInfo.st_mode & (S_IFDIR | S_IREAD | S_IEXEC))
88: ? YES : NO);
89: }
90: if (allOK) {
91: _directory = NXCopyStringBuffer(bp);
92: _codeLoaded = NO;
93: NXMapInsert(pathToBundle, _directory, self);
94: return self;
95: } else {
96: [self free];
97: return nil;
98: }
99: }
100: }
101:
102: - free
103: {
104: if (_codeLoaded)
105: return self;
106: else {
107: NXMapRemove(pathToBundle, _directory);
108: free(_directory);
109: return [super free];
110: }
111: }
112:
113: + mainBundle {
114: if (! mainBundle) {
115: char prog[MAXPATHLEN];
116: char *last;
117: char **argv;
118: #if defined(__DYNAMIC__)
119: extern char ***_NSGetArgv();
120: argv = *_NSGetArgv();
121: #else
122: extern char **NXArgv;
123: argv = NXArgv;
124: #endif
125: if (argv[0][0] != '/') { getwd(prog); strcat(prog, "/"); }
126: else prog[0] = 0;
127: strcat(prog, argv[0]);
128: last = rindex(prog, '/');
129: last[0] = 0;
130: mainBundle = [[self alloc] initForDirectory: prog];
131: mainBundle->_codeLoaded = YES;
132: }
133: return mainBundle;
134: }
135:
136: + bundleForClass:class {
137: id bundle;
138: if (! classToBundle) return [self mainBundle];
139: bundle = NXMapGet(classToBundle, class);
140: return (bundle) ? bundle : [self mainBundle];
141: }
142:
143: - (const char *)directory {
144: return _directory;
145: }
146:
147: static Class globalPrincipalClass = NULL;
148: static id globalBundle = nil;
149:
150: static void loadCallback(Class cls, Category cat ) {
151: warning("Loading %s '%s'\n", (cat) ? "category of" : "class", cls->name);
152: if (cat) return;
153: if (! classToBundle) classToBundle = NXCreateMapTable(NXPtrValueMapPrototype, 1);
154: NXMapInsert(classToBundle, cls, globalBundle);
155: if (! globalPrincipalClass) globalPrincipalClass = cls;
156: }
157:
158: static NXStream* bundleErrorStream = 0;
159:
160: + (NXStream*) setErrorStream:(NXStream*)stream
161: {
162: NXStream* s = bundleErrorStream;
163: bundleErrorStream = stream;
164: return s;
165: }
166:
167: - (BOOL)ensureLoaded {
168: if (! _codeLoaded) {
169: char name[MAXPATHLEN];
170: char path[MAXPATHLEN];
171: char *moduleList[2] = {path, NULL};
172: NXStream *errorStream;
173: long err;
174: char *slash, *dot;
175:
176: globalPrincipalClass = NULL;
177: globalBundle = self;
178: slash = rindex(_directory, '/');
179: if (slash) {
180: strcpy(name, slash + 1);
181: } else {
182: strcpy(name, _directory);
183: }
184: dot = rindex(name, '.');
185: if (dot)
186: *dot = '\0';
187: if ([self getPath: path forResource: name ofType: NULL]) {
188: errorStream = NXOpenMemory(NULL, 0, NX_WRITEONLY);
189:
190: err = objc_loadModules(moduleList, errorStream, loadCallback,
191: NULL, NULL);
192: if (err) {
193: char *streamBuf;
194: int len, maxLen;
195:
196: NXGetMemoryBuffer(errorStream, &streamBuf, &len, &maxLen);
197: if (!bundleErrorStream)
198: {
199: _NXLogError("Error loading %s", path);
200: if (len) {
201: streamBuf[len] = 0;
202: _NXLogError(streamBuf);
203: }
204: _NXLogError("\n");
205: }
206: else
207: {
208: NXPrintf (bundleErrorStream, "Error loading %s", path);
209: if (len) {
210: streamBuf[len] = 0;
211: NXPrintf (bundleErrorStream, streamBuf);
212: }
213: NXPrintf (bundleErrorStream, "\n");
214: }
215: } else {
216: _principalClass = globalPrincipalClass;
217: _codeLoaded = YES;
218: }
219: NXCloseMemory(errorStream, NX_FREEBUFFER|NX_TRUNCATEBUFFER);
220: if (err) return NO;
221: } else {
222: if (! bundleErrorStream)
223: _NXLogError("Couldn't find %s in bundle for %s", name, _directory);
224: else
225: NXPrintf (bundleErrorStream,
226: "Couldn't find %s in bundle for %s", name, _directory);
227: return NO;
228: }
229:
230: }
231: return YES;
232: }
233:
234: - classNamed:(const char *)className {
235: if (![self ensureLoaded]) return nil;
236: return objc_getClass((char *)className);
237: }
238:
239: - principalClass {
240: if (![self ensureLoaded]) return nil;
241: return (id)_principalClass;
242: }
243:
244: - setVersion:(int)version {
245: _bundleVersion = version;
246: return self;
247: }
248:
249: - (int)version {
250: return _bundleVersion;
251: }
252:
253: /******* International Routines ********/
254:
255: static BOOL systemHasLanguages = YES;
256: static const char *const *systemLanguages = NULL;
257:
258: static const char *const *getDefaultSystemLanguages(void) {
259: int count, length;
260: const char *language, *separator;
261: char **defaultSystemLanguages = NULL;
262:
263: if (systemHasLanguages) {
264: language = "English";
265: if (language && *language) {
266: count = 1;
267: separator = strchr(language, ';');
268: while (separator) {
269: count++;
270: separator = strchr(separator+1, ';');
271: }
272: defaultSystemLanguages = malloc((count + 1) * sizeof(char *));
273: defaultSystemLanguages[count] = NULL;
274: for (count = 0; language; count++) {
275: separator = strchr(language, ';');
276: if (separator) {
277: length = separator - language;
278: separator++;
279: } else {
280: length = strlen(language);
281: }
282: while (*language == ' ' || *language == '\t') {
283: language++; length--;
284: }
285: while (language[length-1] == ' ' || language[length-1] == '\t') length--;
286: defaultSystemLanguages[count] = malloc((length + 1) * sizeof(char));
287: strncpy(defaultSystemLanguages[count], language, length);
288: defaultSystemLanguages[count][length] = '\0';
289: language = separator;
290: }
291: } else {
292: systemHasLanguages = NO;
293: }
294: }
295:
296: return defaultSystemLanguages;
297: }
298:
299: #ifdef DEBUG
300: static int ACCESS(const char *path, int way)
301: {
302: int retval = access(path, way);
303: printf("access(%s, R_OK) returns %d\n", path, retval);
304: return retval;
305: }
306: #else
307: #define ACCESS access
308: #endif
309:
310: #define LINE_BUFFER_SIZE 256
311:
312: /* The passed-in path is the .lproj directory to look in for the version. It's not clear what the best way to encode a version into an .lproj directory, but this is probably as good as any...it parses through a file named "version" (if found) looking for an integer value starting a line. If it finds one, that's the version. If no version file exists in the .lproj directory, then its version is 0. */
313:
314: static int readLprojVersion(char *path) {
315: FILE *file;
316: int version = 0;
317: int pathLength = strlen(path);
318:
319: strcat(path, "/version");
320: file = fopen(path, "r");
321: if (file) {
322: char *eof;
323: char lineBuffer[LINE_BUFFER_SIZE+1];
324: *lineBuffer = '\0';
325: do {
326: eof = fgets(lineBuffer, LINE_BUFFER_SIZE, file);
327: version = atoi(lineBuffer);
328: } while (!eof && !version);
329: }
330: path[pathLength] = '\0';
331: fclose(file);
332:
333: return version;
334: }
335:
336: /* Adds the passed extension to the passed name iff the extension is not already on that name. */
337:
338: static void addExtension(char *name, const char *extension)
339: {
340: if (extension) {
341: const char *existingExtension = strrchr(name, '.');
342: if (existingExtension && extension[0] != '.') existingExtension++;
343: if (!existingExtension || strcmp(existingExtension, extension)) {
344: if (extension[0] != '.' && extension[0]) strcat(name, ".");
345: strcat(name, extension);
346: }
347: }
348: }
349:
350: /* This function takes a string and does a readdir() on the passed directory and adds the names of all the files in the directory to that string. Returns a potentially newly realloc()'ed version of the string. */
351:
352: static char *addDirectoryEntriesTo(char *files, const char *directory)
353: {
354: DIR *dirp;
355: struct direct *dp;
356: int length;
357:
358: length = strlen(files);
359: if ((dirp = opendir(directory))) {
360: dp = readdir(dirp); /* Skip . */
361: dp = readdir(dirp); /* Skip .. */
362: for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
363: files = realloc(files, length + dp->d_namlen + 2);
364: strncpy(files + length, dp->d_name, dp->d_namlen);
365: length += dp->d_namlen;
366: files[length++] = '/';
367: }
368: files[length] = '\0';
369: closedir(dirp);
370: }
371:
372: return files;
373: }
374:
375: /* There's a little bit of an efficiency hack in this function. The NXMapTable lprojTable is a map table with keys and values both null-terminated strings. The keys are the path up to and including the .lproj directory. The value is of the form "version/file1/file2/file3/file4". atoi() is used to suck the version out of the front. */
376:
377: static BOOL isFileInValidLproj(char *path, const char *name, const char *extension, int bundleVersion)
378: {
379: char *lprojInfo, *slash;
380: int length, version = -1;
381: char buffer[MAXPATHLEN+1];
382: static NXMapTable *lprojTable = NULL;
383:
384: if (!lprojTable) lprojTable = NXCreateMapTable(NXStrValueMapPrototype, 0);
385:
386: lprojInfo = NXMapGet(lprojTable, path);
387:
388: if (!lprojInfo) {
389: if (ACCESS(path, R_OK) >= 0) version = readLprojVersion(path);
390: sprintf(buffer, "%d/", version);
391: lprojInfo = NXCopyStringBuffer(buffer);
392: lprojInfo = addDirectoryEntriesTo(lprojInfo, path);
393: NXMapInsert(lprojTable, NXCopyStringBuffer(path), lprojInfo);
394: } else {
395: version = atoi(lprojInfo);
396: }
397:
398: if (version == bundleVersion && (lprojInfo = strchr(lprojInfo, '/'))) {
399: strcpy(buffer, name);
400: slash = buffer;
401: while (*slash == '/') slash++;
402: if ((slash = strchr(buffer, '/'))) {
403: *(slash+1) = '\0';
404: } else {
405: addExtension(buffer, extension);
406: strcat(buffer, "/");
407: }
408: length = strlen(buffer);
409: while (*++lprojInfo) {
410: if (!strncmp(lprojInfo, buffer, length)) {
411: if (path[strlen(path)-1] != '/') strcat(path, "/");
412: strcat(path, name);
413: addExtension(path, extension);
414: return slash ? (ACCESS(path, R_OK) >= 0) : YES;
415: }
416: lprojInfo = strchr(lprojInfo, '/');
417: if (!lprojInfo) return NO; /* should never happen */
418: }
419: }
420:
421: return NO;
422: }
423:
424: /* Returns a path to the appropriate shadow .lproj in /NextLibrary/Languages. */
425:
426: static BOOL getPathToNextLibraryLanguages(char *path, const char *realPath, const char *language)
427: {
428: const char *s, *t;
429: char scratch[ MAXPATHLEN+1 ];
430:
431: s = strchr(realPath, '.');
432: while (s) {
433: if (!strncmp(s, ".app", 4)) {
434: char *p;
435: strcpy(scratch, realPath);
436: p = scratch + (s - realPath);
437: t = p+4;
438: if (*t == '/') t++;
439: *p = '\0';
440: s = strrchr(scratch, '/');
441: if (s) {
442: if (*t) {
443: sprintf(path, "/NextLibrary/Languages/%s%s.lproj/%s", language, s, t);
444: } else {
445: sprintf(path, "/NextLibrary/Languages/%s%s.lproj", language, s);
446: }
447: }
448: return YES;
449: } else {
450: s = strchr(s+1, '.');
451: }
452: }
453: if (!s && !strncmp(realPath, "/usr/lib/", 9)) {
454: s = realPath+8;
455: while (*s == '/') s++;
456: if (*s) {
457: s = strchr(s, '/');
458: if (s) {
459: char *tmp;
460:
461: strcpy(scratch, realPath);
462: tmp = scratch + (s - realPath);
463: *tmp++ = '\0';
464: s = tmp;
465: }
466: if (s && *s) {
467: sprintf(path, "/NextLibrary/Languages/%s%s.lproj/%s", language, scratch+8, s);
468: } else {
469: sprintf(path, "/NextLibrary/Languages/%s%s.lproj", language, realPath+8);
470: }
471: return YES;
472: }
473: }
474:
475: return NO;
476: }
477:
478: + (BOOL)getPath:(char *)path forResource:(const char *)name
479: ofType:(const char *)ext inDirectory: (const char *)bundlePath
480: withVersion: (int)version
481: {
482: const char *const *cur;
483: char searchPath[MAXPATHLEN+1];
484:
485: if (!name) return NO;
486: if (!path) path = searchPath;
487:
488: if (!systemLanguages) systemLanguages = getDefaultSystemLanguages();
489:
490: if (systemLanguages) {
491: for (cur = systemLanguages; *cur; cur++) {
492: /* First look for a language in the bundle. */
493: if (bundlePath) {
494: sprintf(path, "%s/%s.lproj", bundlePath, *cur);
495: if (isFileInValidLproj(path, name, ext, version)) return YES;
496: }
497: /* Then look in /NextLibrary/Languages. */
498: if (getPathToNextLibraryLanguages(path, bundlePath, *cur)) {
499: if (isFileInValidLproj(path, name, ext, version)) return YES;
500: }
501: }
502: }
503:
504: sprintf(path, "%s", bundlePath);
505: if (isFileInValidLproj(path, name, ext, version)) return YES;
506:
507: return NO;
508: }
509:
510: -(BOOL)getPath: (char *)path forResource: (const char *)name
511: ofType: (const char *)ext
512: {
513: return [[self class] getPath: path forResource: name ofType: ext
514: inDirectory: _directory withVersion: _bundleVersion];
515: }
516:
517: + setSystemLanguages:(const char *const *)languageList {
518: systemLanguages = languageList;
519: if (!languageList) systemHasLanguages = YES;
520: return self;
521: }
522:
523: @end
524:
525: const char *NXLoadLocalizedStringFromTableInBundle(const char *table, NXBundle *bundle, const char *key, const char *value)
526: {
527: static NXZone *LocalizedStringZone = NULL;
528:
529: #define LSZONE (LocalizedStringZone ? LocalizedStringZone : (LocalizedStringZone = NXDefaultMallocZone()))
530:
531: const char *tableValue;
532: id stringTable, stringTableTable;
533: char path[MAXPATHLEN + 1];
534:
535: if (!key) return value ? value : "";
536: if (!bundle) bundle = [NXBundle mainBundle];
537: if (!table) table = "Localizable";
538:
539: if (bundle != [NXBundle mainBundle]) {
540: stringTableTable = [bundleTable valueForKey:bundle];
541: } else {
542: stringTableTable = mainBundleStringTableTable;
543: }
544:
545: if (!(stringTable = [stringTableTable valueForKey:table])) {
546: [bundle getPath:path forResource:table ofType:"strings"];
547: stringTable = [NXStringTable newFromFile: path];
548: if (!stringTableTable) {
549: if (bundle != [NXBundle mainBundle]) {
550: if (!bundleTable) bundleTable = [[HashTable allocFromZone:LSZONE] initKeyDesc:"!"];
551: if (bundleTable) {
552: stringTableTable = [[HashTable allocFromZone:LSZONE] initKeyDesc:"*"];
553: if (stringTableTable) [bundleTable insertKey:bundle value:stringTableTable];
554: }
555: } else {
556: mainBundleStringTableTable = stringTableTable = [[HashTable allocFromZone:LSZONE] initKeyDesc:"*"];
557: }
558: }
559: if (stringTableTable && !stringTable) stringTable = [[NXStringTable allocFromZone:LSZONE] init];
560: if (stringTable) [stringTableTable insertKey:table value:stringTable];
561: }
562:
563: if (!(tableValue = [stringTable valueForStringKey:key])) {
564: tableValue = value ? value : key;
565: [stringTable insertKey:key value:(void *)tableValue];
566: }
567:
568: return tableValue;
569: }
570: const char *NXLoadLocalStringFromTableInBundle(const char *table, NXBundle *bundle, const char *key, const char *value)
571: {
572: return NXLoadLocalizedStringFromTableInBundle(table, bundle, key, value);
573: }
574: @implementation NXBundle (Compatability)
575:
576: - initForPath: (const char *)path { return [self initForDirectory: path]; }
577: - (const char *)path { return [self directory]; }
578: + forClass: class { return [self bundleForClass: class]; }
579: + newFromPath:(const char *)bp { return [[self alloc] initForPath: bp]; }
580: - initFromPath:(const char *)bp { return [self initForPath: bp]; }
581: - (const char *)bundlePath { return [self path]; }
582: - (BOOL)codeLoaded { return _codeLoaded; }
583: - firstClass { return [self principalClass]; }
584: - (BOOL)getResourcePath:(char *)path forName:(const char *)name type:(const char *)ext { return [self getPath: path forResource: name ofType: ext]; }
585: - getClass: (const char *)className { return [self classNamed: className]; }
586: - classForName: (const char *)className { return [self classNamed: className]; }
587:
588: @end
589:
590: @implementation NXBundle (Private)
591:
592: static void noFree(void *ptr) {}
593: static void freeObjects(void *ptr)
594: {
595: [(HashTable *)ptr freeObjects];
596: [(HashTable *)ptr free];
597: }
598:
599: + (void)_invalidateLprojCache
600: {
601: if (bundleTable) {
602: [bundleTable freeKeys: noFree values: freeObjects];
603: [bundleTable free];
604: bundleTable = nil;
605: }
606: if (mainBundleStringTableTable) {
607: [mainBundleStringTableTable freeObjects];
608: [mainBundleStringTableTable free];
609: mainBundleStringTableTable = nil;
610: }
611: }
612:
613: @end
614: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.