![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to NXPropertyList.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 NXPropertyList.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: /* NXPropertyList.m
25: Copyright 1991, NeXT, Inc.
26: Bertrand, August 1991
27: */
28: #ifndef KERNEL
29: #import "NXPropertyList.h"
30:
31: #import <ctype.h>
32: #import <streams/streams.h>
33: #import <stdio.h>
34:
35: /******** String extras ********/
36:
37: @interface NXMutableString (NX_BS_Extras)
38: //?? SHOULD BE IN NXString, AND EFFICIENT!
39: - (void)appendCharacters:(const unichar *)chars length:(unsigned)length;
40: @end
41:
42: @implementation NXMutableString (NX_BS_Extras)
43: - (void)appendCharacters:(const unichar *)chars length:(unsigned)length {
44: NXReadWriteString *temp = [NXReadOnlyString alloc];
45: [temp initFromCharactersNoCopy:(unichar *)chars length:length freeWhenDone:NO];
46: [self append:temp];
47: [temp free];
48: }
49: @end
50:
51: @interface Object (NX_BS_Extras)
52: //?? Should be in ObjC
53: // Assumed by ipclib
54: - (void)writeToStream:(NXStream *)stream;
55: @end
56:
57: @implementation Object (NX_BS_Extras)
58: - (void)writeToStream:(NXStream *)stream {
59: NXPrintf(stream, "0x%x", self);
60: }
61: @end
62:
63: /******** Class implementation ********/
64:
65: @implementation NXPropertyList
66:
67: static void freeKeyAndValue(NXMapTable *table, void *key, void *value) {
68: [(id)key free];
69: [(id)value free];
70: }
71:
72: - init {
73: NXMapTablePrototype proto = NXObjectMapPrototype;
74: proto.free = freeKeyAndValue;
75: table = NXCreateMapTable(proto, 0);
76: return self;
77: }
78:
79: - free {
80: /* we test for table NULL for cases when free is called during initialization */
81: if (table) NXFreeMapTable(table);
82: return [super free];
83: }
84:
85: - (unsigned)count {
86: return NXCountMapTable(table);
87: }
88:
89: - (BOOL)member:(NXString *)key {
90: id value;
91: return (NXMapMember(table, key, (void **)&value) != NX_MAPNOTAKEY);
92: }
93:
94: - get:(NXString *)key {
95: return NXMapGet(table, key);
96: }
97:
98: - insert:(NXString *)key value:value {
99: id oldValue;
100: void *oldKey = NXMapMember(table, key, (void **)&oldValue);
101: if (oldKey == NX_MAPNOTAKEY) {
102: oldValue = nil;
103: } else {
104: (void)NXMapRemove(table, oldKey);
105: [(id)oldKey free];
106: }
107: (void)NXMapInsert(table, [key immutableCopy], value);
108: return oldValue;
109: }
110:
111: - remove:(NXString *)key {
112: id oldValue;
113: void *oldKey = NXMapMember(table, key, (void **)&oldValue);
114: if (oldKey == NX_MAPNOTAKEY) return nil;
115: NXMapRemove(table, oldKey);
116: [(id)oldKey free];
117: return oldValue;
118: }
119:
120: - empty {
121: NXResetMapTable(table);
122: return self;
123: }
124:
125: - (NXMapState)initEnumeration {
126: return NXInitMapState(table);
127: }
128:
129: - (BOOL)enumerate:(NXMapState *)state key:(NXString **)refKey value:(id *)refValue {
130: return NXNextMapState(table, state, (void **)refKey, (void **)refValue) != 0;
131: }
132:
133: @end
134:
135: /******** Basic ASCII read/write of property lists ********/
136:
137: @implementation NXPropertyList (Basic_IO)
138: - initFromStream:(NXStream *)stream {
139: NXPropertyListReadContext context = {
140: 0, [NXReadWriteString new],
141: [NXReadOnlyString class],
142: [NXReadOnlyString class],
143: [NXCleanList class],
144: [NXPropertyList class],
145: YES,
146: [self zone],
147: NULL
148: };
149: id new = [self initFromStream:stream context:&context];
150: [context.buffer free];
151: if (context.uniquingTable) NXFreeHashTable(context.uniquingTable);
152: return new;
153: }
154:
155: - initFromPath:(NXString *)path {
156: NXPropertyListReadContext context = {
157: 0, [NXReadWriteString new],
158: [NXReadOnlyString class],
159: [NXReadOnlyString class],
160: [NXCleanList class],
161: [NXPropertyList class],
162: YES,
163: [self zone],
164: NULL
165: };
166: id new = [self initFromPath:path context:&context];
167: [context.buffer free];
168: if (context.uniquingTable) NXFreeHashTable(context.uniquingTable);
169: return new;
170: }
171:
172: - (void)writeToStream:(NXStream *)stream {
173: NXPropertyListWriteContext context = {
174: 4, 0,
175: NO, "\n"
176: };
177: [self writeToStream:stream context:&context];
178: }
179:
180: - (BOOL)writeToPath:(NXString *)path safely:(BOOL)safe {
181: char cpath[MAXPATHLEN];
182: char temp[MAXPATHLEN];
183: NXStream *stream;
184: BOOL ok;
185: if (! path) return NO;
186: [path getCString:cpath]; cpath[[path length]] = 0;
187: stream = NXOpenMemory(NULL, 0, NX_WRITEONLY);
188: strcpy(temp, cpath);
189: if (safe) strcat(temp, "~");
190: [self writeToStream:stream];
191: ok = ! NXSaveToFile(stream, temp);
192: NXCloseMemory(stream, NX_FREEBUFFER);
193: if (safe && ok) ok = ! rename(temp, cpath);
194: return ok;
195: }
196:
197: - (BOOL)writeToPath:(NXString *)path {
198: return [self writeToPath:path safely:YES];
199: }
200:
201: @end
202:
203: /******** Read/write utilities ********/
204:
205: // constants
206: #define BEGIN_PAR '('
207: #define END_PAR ')'
208: #define BEGIN_CURLY '{'
209: #define END_CURLY '}'
210:
211: static int NXGetNonSpace(NXStream *stream, int *line) {
212: int ch;
213: while ((ch = NXGetc(stream)) != EOF) {
214: if (ch == '\n') (*line)++;
215: if (ch == '/') {
216: if ((ch = NXGetc(stream)) == '/') {
217: while ((ch = NXGetc(stream)) != EOF && ch != '\n') {};
218: if (ch == '\n') (*line)++;
219: } else if (ch == '*') {
220: while ((ch = NXGetc(stream)) != EOF) {
221: if (ch == '*') {
222: ch = NXGetc(stream);
223: if (ch == '/') break;
224: NXUngetc(stream);
225: } else if (ch == '\n') (*line)++;
226: }
227: } else {
228: NXUngetc(stream);
229: return '/';
230: }
231: } else if (! isspace(ch)) return ch;
232: }
233: return EOF;
234: }
235:
236: static inline int isTokenChar(int ch) {
237: return (isalnum(ch) || ch == '_' || ch == '$' || ch == ':' || ch == '.' || ch == '/') ? 1 : 0;
238: }
239:
240: static int NXGetSlashedChar(NXStream *stream, int *line) {
241: int ch;
242: switch (ch = NXGetc(stream)) {
243: case '0':
244: case '1':
245: case '2':
246: case '3':
247: case '4':
248: case '5':
249: case '6':
250: case '7': {
251: int num = ch - '0';
252: /* three digits maximum to avoid reading \000 followed by 5 as \5 ! */
253: if ((ch = NXGetc(stream)) >= '0' && ch <= '7') {
254: num = (num << 3) + ch - '0';
255: if ((ch = NXGetc(stream)) >= '0' && ch <= '7') {
256: num = (num << 3) + ch - '0';
257: } else NXUngetc(stream);
258: } else NXUngetc(stream);
259: return num;
260: }
261: case 'a': return '\a';
262: case 'b': return '\b';
263: case 'f': return '\f';
264: case 'n': return '\n';
265: case 'r': return '\r';
266: case 't': return '\t';
267: case 'v': return '\v';
268: case '"': return '\"';
269: case '\n': (*line)++;
270: return '\n';
271: }
272: return ch;
273: }
274:
275: static id readValue(NXStream *stream, NXPropertyListReadContext *context) {
276: int ch = NXGetNonSpace(stream, &context->line);
277: if (ch == BEGIN_CURLY || ch == BEGIN_PAR) {
278: id factory;
279: int endch;
280: id value;
281: if (ch == BEGIN_CURLY) {
282: factory = context->propertyListValueFactory;
283: endch = END_CURLY;
284: } else {
285: factory = context->listValueFactory;
286: endch = END_PAR;
287: }
288: value = [[factory allocFromZone:context->zone] initFromStream:stream context:context];
289: if (! value) return nil;
290: ch = NXGetNonSpace(stream, &context->line);
291: if (ch != endch) {
292: [value free];
293: return nil;
294: }
295: return value;
296: } else {
297: NXUngetc(stream);
298: return [[context->stringValueFactory allocFromZone:context->zone] initFromStream:stream context:context];
299: }
300: }
301:
302: static void writeSpaces(NXStream *stream, int spaces) {
303: while (spaces >= 8) {
304: NXPutc(stream, '\t'); spaces -= 8;
305: }
306: while (spaces--) NXPutc(stream, ' ');
307: }
308:
309: /******** A list that really frees its elements ********/
310:
311: @implementation NXCleanList:List
312: - free {
313: [self freeObjects];
314: return [super free];
315: }
316: @end
317:
318: /******** Fancy ASCII read/write of property lists ********/
319:
320: @implementation NXPropertyList (Fancy_IO)
321: - initFromStream:(NXStream *)stream context:(NXPropertyListReadContext *)context {
322: int ch = NXGetNonSpace(stream, &context->line);
323: BOOL ok = YES;
324: [self init];
325: while (ok && (ch == '"' || isTokenChar(ch))) {
326: NXString *key;
327: id value;
328: NXUngetc(stream);
329: key = [[context->keyFactory allocFromZone:context->zone] initFromStream:stream context:context];
330: if (! key) return NO;
331: ch = NXGetNonSpace(stream, &context->line);
332: if (ch == '=') {
333: value = readValue(stream, context);
334: if (! value) {
335: printf("*** NXPropertyList: Syntax error line %u\n", context->line);
336: [self free];
337: return nil;
338: }
339: [self insert:key value:value];
340: ch = NXGetNonSpace(stream, &context->line);
341: } else {
342: [self insert:key value:(context->noValueIsSame) ? [key immutableCopy] : nil];
343: }
344: [key free];
345: ok = NO;
346: while (ch == ';') {
347: ok = YES; ch = NXGetNonSpace(stream, &context->line);
348: }
349: }
350: NXUngetc(stream);
351: return self;
352: }
353:
354: - (void)writeToStream:(NXStream *)stream context:(NXPropertyListWriteContext *)context {
355: NXMapState state = [self initEnumeration];
356: id key;
357: id value;
358: NXPropertyListWriteContext original = *context;
359: unsigned spaces = context->indent;
360: if (original.topLevelBrackets) NXPutc(stream, BEGIN_CURLY);
361: while ([self enumerate:&state key:&key value:&value]) {
362: context->topLevelBrackets = YES;
363: context->pairSeparator = original.pairSeparator;
364: writeSpaces(stream, spaces);
365: if (key == value) {
366: [key writeToStream:stream context:context];
367: NXPrintf(stream, ";");
368: } else if ([value isKindOf:[NXPropertyList class]]) {
369: [key writeToStream:stream context:context];
370: NXPrintf(stream, " = {%s", original.pairSeparator);
371: context->topLevelBrackets = NO;
372: context->indent = spaces + context->indentDelta;
373: [value writeToStream:stream context:context];
374: writeSpaces(stream, spaces);
375: NXPrintf(stream, "};");
376: } else if (value) {
377: [key writeToStream:stream context:context];
378: NXPrintf(stream, " = ");
379: [value writeToStream:stream context:context];
380: NXPrintf(stream, ";");
381: }
382: NXPrintf(stream, "%s", original.pairSeparator);
383: }
384: if (original.topLevelBrackets) NXPutc(stream, END_CURLY);
385: }
386: - initFromPath:(NXString *)path context:(NXPropertyListReadContext *)context {
387: char cpath[MAXPATHLEN];
388: NXStream *stream;
389: id new;
390: if (! path) goto nope;
391: [path getCString:cpath]; cpath[[path length]] = 0;
392: stream = NXMapFile(cpath, NX_READONLY);
393: if (! stream) goto nope;
394: new = [self initFromStream:stream context:context];
395: if (NXGetc(stream) != EOF) {
396: char cpath[MAXPATHLEN];
397: [path getCString:cpath];
398: printf("NXPropertyList: discarded input at line %u of file %s\n", context->line, cpath);
399: }
400: NXCloseMemory(stream, NX_FREEBUFFER);
401: return new;
402: nope:
403: [self free];
404: return nil;
405: }
406:
407: @end
408:
409: @implementation NXCleanList (Fancy_IO)
410: - initFromStream:(NXStream *)stream context:(NXPropertyListReadContext *)context {
411: BOOL ok = YES;
412: int ch = NXGetNonSpace(stream, &context->line);
413: while (ok && (ch == '"' || isTokenChar(ch) || ch == BEGIN_CURLY || ch == BEGIN_PAR)) {
414: id value;
415: NXUngetc(stream);
416: value = readValue(stream, context);
417: if (! value) {
418: printf("*** NXCleanList: Syntax error line %u\n", context->line);
419: [self free];
420: return nil;
421: }
422: [self addObject:value];
423: ch = NXGetNonSpace(stream, &context->line);
424: ok = NO;
425: while (ch == ',') {
426: ok = YES; ch = NXGetNonSpace(stream, &context->line);
427: }
428: }
429: NXUngetc(stream);
430: return self;
431: }
432:
433:
434: - (void)writeToStream:(NXStream *)stream context:(NXPropertyListWriteContext *)context {
435: unsigned index = 0;
436: unsigned count = [self count];
437: BOOL top = context->topLevelBrackets;
438: if (top) NXPutc(stream, BEGIN_PAR);
439: while (index < count) {
440: context->topLevelBrackets = YES;
441: context->pairSeparator = "";
442: context->indent = 0;
443: [[self objectAt:index] writeToStream:stream context:context];
444: if (index != count-1) NXPrintf(stream, ", ");
445: index++;
446: }
447: if (top) NXPutc(stream, END_PAR);
448: }
449:
450: @end
451:
452: @implementation NXString (Fancy_IO)
453:
454: #define MAX_TOKEN 1024
455:
456: static inline void append1(NXMutableString *buffer, BOOL *bufferUsed, int ch, unichar *buf, unsigned *buflen) {
457: if (*buflen == MAX_TOKEN) {
458: if (! *bufferUsed) [buffer replaceWith:@""];
459: *bufferUsed = YES;
460: [buffer appendCharacters:buf length:MAX_TOKEN];
461: *buflen = 0;
462: }
463: buf[(*buflen)++] = ch;
464: }
465:
466: static inline NXString *init(NXString *self, NXMutableString *buffer, BOOL bufferUsed, unichar *buf, unsigned *buflen) {
467: if (bufferUsed) {
468: [buffer appendCharacters:buf length:*buflen];
469: return [self initFromString:buffer];
470: }
471: return [self initFromCharacters:buf length:*buflen];
472: }
473:
474: - initFromStream:(NXStream *)stream context:(NXPropertyListReadContext *)context {
475: int ch = NXGetNonSpace(stream, &context->line);
476: if (ch == '"') {
477: BOOL bufferUsed = NO;
478: unichar buf[MAX_TOKEN];
479: unsigned buflen = 0;
480: while (((ch = NXGetc(stream)) != EOF) && (ch != '"')) {
481: if (ch == '\n') (context->line)++;
482: if (ch == '\\') ch = NXGetSlashedChar(stream, &context->line);
483: append1(context->buffer, &bufferUsed, ch, buf, &buflen);
484: }
485: if (ch == EOF) {
486: [self free];
487: return nil;
488: }
489: return init(self, context->buffer, bufferUsed, buf, &buflen);
490: } else if (isTokenChar(ch)) {
491: BOOL bufferUsed = NO;
492: unichar buf[MAX_TOKEN];
493: unsigned buflen = 0;
494: append1(context->buffer, &bufferUsed, ch, buf, &buflen);
495: while (((ch = NXGetc(stream)) != EOF) && isTokenChar(ch)) {
496: append1(context->buffer, &bufferUsed, ch, buf, &buflen);
497: }
498: NXUngetc(stream);
499: return init(self, context->buffer, bufferUsed, buf, &buflen);
500: } else {
501: NXUngetc(stream);
502: [self free];
503: return nil;
504: }
505: }
506:
507: - (void)writeToStream:(NXStream *)stream context:(NXPropertyListWriteContext *)context {
508: unsigned index = 0;
509: unsigned count = [self length];
510: BOOL token = (count != 0);
511: while (index < count) {
512: int ch = [self characterAt:index];
513: if (! isTokenChar(ch)) { token = NO; break; }
514: index ++;
515: }
516: if (token) {
517: NXPrintf(stream, "%@", self);
518: } else {
519: NXPutc(stream, '"');
520: index = 0;
521: while (index < count) {
522: int ch = [self characterAt:index];
523: int ch1 = '\\', ch2 = 0;
524: switch (ch) {
525: case '\\': ch2 = ch; break;
526: case '"': ch2 = ch; break;
527: case '\a': ch2 = 'a'; break;
528: case '\b': ch2 = 'b'; break;
529: case '\f': ch2 = 'f'; break;
530: case '\n': ch2 = 'n'; break;
531: case '\t': ch2 = 't'; break;
532: case '\v': ch2 = 'v'; break;
533: default:
534: if (ch >= ' ' && ch <= '~') {
535: ch1 = ch;
536: } else {
537: /* attention here: if the next character is a number, we need to avoid \0 followed by 5 that would become \05. We do that by printing 3 digits */
538: NXPrintf(stream, "\\%+03o", ch);
539: ch1 = 0;
540: }
541: }
542: if (ch1) {
543: NXPutc(stream, ch1);
544: if (ch2) NXPutc(stream, ch2);
545: }
546: index ++;
547: }
548: NXPutc(stream, '"');
549: }
550: }
551:
552: @end
553:
554: @implementation NXReadOnlyString (Fancy_IO)
555: // Only this class tries uniquing the strings
556: static unsigned hashString(const void *info, const void *data) {
557: return [(NXString *)data hash];
558: }
559: static int isEqualString(const void *info, const void *data1, const void *data2) {
560: return [(NXString *)data1 isEqual:(NXString *)data2];
561: }
562: static void freeString(const void *info, const void *data) {
563: [(NXString *)data free];
564: }
565:
566: - initFromStream:(NXStream *)stream context:(NXPropertyListReadContext *)context {
567: NXString *new = [super initFromStream:stream context:context];
568: NXString *original;
569: if (! new) return new;
570: if (! context->uniquingTable) {
571: NXHashTablePrototype stringSetProto = {hashString, isEqualString, freeString, 0};
572: context->uniquingTable = NXCreateHashTable(stringSetProto, 0, 0);
573: }
574: original = NXHashGet(context->uniquingTable, new);
575: if (! original) {
576: NXHashInsert(context->uniquingTable, [new immutableCopy]);
577: return new;
578: } else {
579: [new free];
580: return [original immutableCopy];
581: }
582: }
583: @end
584:
585: @implementation Object (Fancy_IO)
586: - (void)writeToStream:(NXStream *)stream context:(NXPropertyListWriteContext *)context {
587: [self writeToStream:stream];
588: }
589: @end
590:
591: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.