#import "common.h"

#import "GNUstepBase/GSMime.h"

#import "Foundation/NSArray.h"

#import "Foundation/NSAutoreleasePool.h"

#import "Foundation/NSByteOrder.h"

#import "Foundation/NSCalendarDate.h"

#import "Foundation/NSCharacterSet.h"

#import "Foundation/NSData.h"

#import "Foundation/NSDictionary.h"

#import "Foundation/NSEnumerator.h"

#import "Foundation/NSError.h"

#import "Foundation/NSException.h"

#import "Foundation/NSHashTable.h"

#import "Foundation/NSPropertyList.h"

#import "Foundation/NSSerialization.h"

#import "Foundation/NSStream.h"

#import "Foundation/NSTimeZone.h"

#import "Foundation/NSUserDefaults.h"

#import "Foundation/NSValue.h"

#import "Foundation/NSNull.h"

#import "Foundation/NSXMLParser.h"

#import "GNUstepBase/Unicode.h"

#import "GNUstepBase/NSProcessInfo+GNUstepBase.h"

#import "GNUstepBase/NSString+GNUstepBase.h"

#import "GSPrivate.h"

static id boolN = nil;

static id boolY = nil;

static const char *prefix =

"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

"<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" "

"\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"

"<plist version=\"1.0\">\n";

@class GSSloppyXMLParser;

#define inrange(ch,min,max) ((ch)>=(min) && (ch)<=(max))

#define char2num(ch) \

inrange(ch,'0','9') \

? ((ch)-0x30) \

: (inrange(ch,'a','f') \

? ((ch)-0x57) : ((ch)-0x37))

static Class NSArrayClass;

static Class NSDataClass;

static Class NSDateClass;

static Class NSDictionaryClass;

static Class NSNumberClass;

static Class NSStringClass;

static Class NSMutableStringClass;

static Class GSStringClass;

static Class GSMutableStringClass;

@class GSMutableDictionary;

@interface GSMutableDictionary : NSObject // Help the compiler

@interface GSXMLPListParser : NSObject

{

NSXMLParser *theParser;

NSMutableString *value;

NSMutableArray *stack;

id key;

BOOL inArray;

BOOL inDictionary;

BOOL inPCData;

BOOL parsed;

BOOL success;

id plist;

NSPropertyListMutabilityOptions opts;

}

- (id) initWithData: (NSData*)data

mutability: (NSPropertyListMutabilityOptions)options;

- (BOOL) parse;

- (void) parser: (NSXMLParser *)parser

foundCharacters: (NSString *)string;

- (void) parser: (NSXMLParser *)parser

didStartElement: (NSString *)elementName

namespaceURI: (NSString *)namespaceURI

qualifiedName: (NSString *)qualifiedName

attributes: (NSDictionary *)attributeDict;

- (void) parser: (NSXMLParser *)parser

didEndElement: (NSString *)elementName

namespaceURI: (NSString *)namespaceURI

qualifiedName: (NSString *)qName;

- (id) result;

- (void) unescape;

@interface GSSloppyXMLParser : NSXMLParser

@implementation GSXMLPListParser

- (void) dealloc

{

RELEASE(key);

RELEASE(stack);

RELEASE(plist);

RELEASE(value);

RELEASE(theParser);

[super dealloc];

}

- (id) initWithData: (NSData*)data

mutability: (NSPropertyListMutabilityOptions)options

{

if ((self = [super init]) != nil)

{

theParser = [[GSSloppyXMLParser alloc] initWithData: data];

[theParser setDelegate: self];

opts = options;

}

return self;

}

- (void) parser: (NSXMLParser *)parser

foundCharacters: (NSString *)string

{

if (YES == inPCData)

{

[value appendString: string];

}

else

{

[value appendString: [string stringByTrimmingSpaces]];

}

}

- (void) parser: (NSXMLParser *)parser

foundIgnorableWhitespace: (NSString *)string

{

if (YES == inPCData)

{

[value appendString: string];

}

}

- (void) parser: (NSXMLParser *)parser

didStartElement: (NSString *)elementName

namespaceURI: (NSString *)namespaceURI

qualifiedName: (NSString *)qualifiedName

attributes: (NSDictionary *)attributeDict

{

if ([elementName isEqualToString: @"dict"] == YES)

{

NSMutableDictionary *d;

if (key == nil)

{

key = [[NSNull null] retain];

}

[stack addObject: key];

DESTROY(key);

d = [[NSMutableDictionary alloc] initWithCapacity: 10];

[stack addObject: d];

RELEASE(d);

inDictionary = YES;

inArray = NO;

}

else if ([elementName isEqualToString: @"array"] == YES)

{

NSMutableArray *a;

if (key == nil)

{

key = [[NSNull null] retain];

}

[stack addObject: key];

DESTROY(key);

a = [[NSMutableArray alloc] initWithCapacity: 10];

[stack addObject: a];

RELEASE(a);

inArray = YES;

inDictionary = NO;

}

else if ([elementName isEqualToString: @"plist"] == NO)

{

inPCData = YES;

}

}

- (void) parser: (NSXMLParser *)parser

didEndElement: (NSString *)elementName

namespaceURI: (NSString *)namespaceURI

qualifiedName: (NSString *)qName

{

BOOL inContainer = NO;

inPCData = NO;

if ([elementName isEqualToString: @"dict"] == YES)

{

inContainer = YES;

}

else if ([elementName isEqualToString: @"array"] == YES)

{

inContainer = YES;

}

if (inContainer)

{

if (opts != NSPropertyListImmutable)

{

ASSIGN(plist, [stack lastObject]);

}

else

{

NSObject *o = [stack lastObject];

if ([o makeImmutable] == YES)

{

ASSIGN(plist, o);

}

else

{

ASSIGNCOPY(plist, o);

}

}

[stack removeLastObject];

inArray = NO;

inDictionary = NO;

ASSIGN(key, [stack lastObject]);

[stack removeLastObject];

if ((id)key == (id)[NSNull null])

{

DESTROY(key);

}

if ([stack count] > 0)

{

id last;

last = [stack lastObject];

if ([last isKindOfClass: NSArrayClass] == YES)

{

inArray = YES;

}

else if ([last isKindOfClass: NSDictionaryClass] == YES)

{

inDictionary = YES;

}

}

}

else if ([elementName isEqualToString: @"key"] == YES)

{

[self unescape];

ASSIGNCOPY(key, value);

[value setString: @""];

return;

}

else if ([elementName isEqualToString: @"data"])

{

NSData *d;

d = [GSMimeDocument decodeBase64:

[value dataUsingEncoding: NSASCIIStringEncoding]];

if (opts == NSPropertyListMutableContainersAndLeaves)

{

d = AUTORELEASE([d mutableCopy]);

}

ASSIGN(plist, d);

if (d == nil)

{

[parser abortParsing];

return;

}

}

else if ([elementName isEqualToString: @"date"])

{

id result;

if ([value hasSuffix: @"Z"] == YES && [value length] == 20)

{

result = [NSCalendarDate dateWithString: value

calendarFormat: @"%Y-%m-%dT%H:%M:%SZ"];

}

else

{

result = [NSCalendarDate dateWithString: value

calendarFormat: @"%Y-%m-%d %H:%M:%S %z"];

}

ASSIGN(plist, result);

}

else if ([elementName isEqualToString: @"string"])

{

id o;

[self unescape];

if (opts == NSPropertyListMutableContainersAndLeaves)

{

o = [value mutableCopy];

}

else

{

o = [value copy];

}

ASSIGN(plist, o);

[o release];

}

else if ([elementName isEqualToString: @"integer"])

{

if ([value hasPrefix: @"-"])

{

ASSIGN(plist, [NSNumber numberWithLongLong: [value longLongValue]]);

}

else

{

ASSIGN(plist, [NSNumber numberWithUnsignedLongLong:

(unsigned long long)[value longLongValue]]);

}

}

else if ([elementName isEqualToString: @"real"])

{

ASSIGN(plist, [NSNumber numberWithDouble: strtod([value cString], NULL)]);

}

else if ([elementName isEqualToString: @"true"])

{

ASSIGN(plist, boolY);

}

else if ([elementName isEqualToString: @"false"])

{

ASSIGN(plist, boolN);

}

else if ([elementName isEqualToString: @"plist"])

{

[value setString: @""];

return;

}

else // invalid tag

{

// NSLog(@"unrecognized tag <%@>", elementName);

[parser abortParsing];

return;

}

if (inArray == YES)

{

[[stack lastObject] addObject: plist];

}

else if (inDictionary == YES)

{

if (key == nil)

{

[parser abortParsing];

return;

}

[(NSMutableDictionary*)[stack lastObject] setObject: plist forKey: key];

DESTROY(key);

}

[value setString: @""];

}

- (BOOL) parse

{

if (parsed == NO)

{

parsed = YES;

stack = [[NSMutableArray alloc] initWithCapacity: 10];

value = [[NSMutableString alloc] initWithCapacity: 50];

success = [theParser parse];

}

return success;

}

- (id) result

{

return plist;

}

- (void) unescape

{

id o;

NSRange r;

/* Convert any \Uxxxx sequences to unicode characters.

r = NSMakeRange(0, [value length]);

while (r.length >= 6)

{

r = [value rangeOfString: @"\\U" options: NSLiteralSearch range: r];

if (r.length == 2 && [value length] >= r.location + 6)

{

unichar c;

unichar v;

c = [value characterAtIndex: r.location + 2];

if (isxdigit(c))

{

v = char2num(c);

c = [value characterAtIndex: r.location + 3];

if (isxdigit(c))

{

v <<= 4;

v |= char2num(c);

c = [value characterAtIndex: r.location + 4];

if (isxdigit(c))

{

v <<= 4;

v |= char2num(c);

c = [value characterAtIndex: r.location + 5];

if (isxdigit(c))

{

v <<= 4;

v |= char2num(c);

o = [NSString alloc];

o = [o initWithCharacters: &v length: 1];

r.length += 4;

[value replaceCharactersInRange: r withString: o];

[o release];

r.location++;

r.length = 0;

}

}

}

}

r = NSMakeRange(NSMaxRange(r), [value length] - NSMaxRange(r));

}

}

}

@interface GSBinaryPLParser : NSObject

{

NSPropertyListMutabilityOptions mutability;

unsigned _length;

const unsigned char *_bytes;

NSData *data;

unsigned offset_size; // Number of bytes per table entry

unsigned index_size; // Number of bytes per table entry

unsigned object_count; // Number of objects

unsigned root_index; // Index of root object

unsigned table_start; // Start address of object table

NSHashTable *_stack; // The stack of objects we are currently parsing

}

- (id) initWithData: (NSData*)plData

mutability: (NSPropertyListMutabilityOptions)m;

- (id) rootObject;

- (id) objectAtIndex: (NSUInteger)index;

@interface GSBinaryPLGenerator : NSObject

{

NSMutableData *dest;

NSMapTable *objectList;

NSMutableArray *objectsToDoList;

id root;

// Number of bytes per object table index

unsigned int index_size;

// Number of bytes per object table entry

unsigned int offset_size;

unsigned int table_start;

unsigned int table_size;

unsigned int *table;

}

+ (void) serializePropertyList: (id)aPropertyList

intoData: (NSMutableData *)destination;

- (id) initWithPropertyList: (id)aPropertyList

intoData: (NSMutableData *)destination;

- (void) generate;

- (BOOL) storeObject: (id)object;

- (void) cleanup;

static Class plArray;

static id (*plAdd)(id, SEL, id) = 0;

static Class plDictionary;

static id (*plSet)(id, SEL, id, id) = 0;

static const unsigned char quotables[32] = {

'\xff',

'\xff',

'\xff',

'\xff',

'\x85',

'\x13',

'\x00',

'\x78',

'\x00',

'\x00',

'\x00',

'\x38',

'\x01',

'\x00',

'\x00',

'\xa8',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

'\xff',

};

static const unsigned char whitespace[32] = {

'\x00',

'\x3f',

'\x00',

'\x00',

'\x01',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

'\x00',

};

#define IS_BIT_SET(a,i) ((((a) & (1<<(i)))) > 0)

#define GS_IS_QUOTABLE(X) IS_BIT_SET(quotables[(X)/8], (X) % 8)

#define GS_IS_WHITESPACE(X) IS_BIT_SET(whitespace[(X)/8], (X) % 8)

static NSCharacterSet *oldQuotables = nil;

static NSCharacterSet *xmlQuotables = nil;

typedef struct {

const unsigned char *ptr;

unsigned end;

unsigned pos;

unsigned lin;

NSString *err;

NSPropertyListMutabilityOptions opt;

BOOL key;

BOOL old;

} pldata;

static BOOL skipSpace(pldata *pld)

{

unsigned char c;

while (pld->pos < pld->end)

{

c = pld->ptr[pld->pos];

if (GS_IS_WHITESPACE(c) == NO)

{

if (c == '/' && pld->pos < pld->end - 1)

{

/*

if (pld->ptr[pld->pos + 1] == '/')

{

pld->pos += 2;

while (pld->pos < pld->end)

{

c = pld->ptr[pld->pos];

if (c == '\n')

{

break;

}

pld->pos++;

}

if (pld->pos >= pld->end)

{

pld->err = @"reached end of string in comment";

return NO;

}

}

else if (pld->ptr[pld->pos + 1] == '*')

{

pld->pos += 2;

while (pld->pos < pld->end)

{

c = pld->ptr[pld->pos];

if (c == '\n')

{

pld->lin++;

}

else if (c == '*' && pld->pos < pld->end - 1

&& pld->ptr[pld->pos+1] == '/')

{

pld->pos++; /* Skip past '*' */

break;

}

pld->pos++;

}

if (pld->pos >= pld->end)

{

pld->err = @"reached end of string in comment";

return NO;

}

}

else

{

return YES;

}

}

else

{

return YES;

}

}

if (c == '\n')

{

pld->lin++;

}

pld->pos++;

}

pld->err = @"reached end of string";

return NO;

}

static inline id parseQuotedString(pldata* pld)

{

unsigned start = ++pld->pos;

unsigned escaped = 0;

unsigned shrink = 0;

BOOL hex = NO;

NSString *obj;

while (pld->pos < pld->end)

{

unsigned char c = pld->ptr[pld->pos];

if (escaped)

{

if (escaped == 1 && c >= '0' && c <= '7')

{

escaped = 2;

hex = NO;

}

else if (escaped == 1 && (c == 'u' || c == 'U'))

{

escaped = 2;

hex = YES;

}

else if (escaped > 1)

{

if (hex && isxdigit(c))

{

shrink++;

escaped++;

if (escaped == 6)

{

escaped = 0;

}

}

else if (c >= '0' && c <= '7')

{

shrink++;

escaped++;

if (escaped == 4)

{

escaped = 0;

}

}

else

{

pld->pos--;

escaped = 0;

}

}

else

{

escaped = 0;

}

}

else

{

if (c == '\\')

{

escaped = 1;

shrink++;

}

else if (c == '"')

{

break;

}

}

if (c == '\n')

pld->lin++;

pld->pos++;

}

if (pld->pos >= pld->end)

{

pld->err = @"reached end of string while parsing quoted string";

return nil;

}

if (pld->pos - start - shrink == 0)

{

obj = @"";

}

else

{

unsigned length;

unichar *chars;

unichar *temp = NULL;

unsigned int temp_length = 0;

unsigned j;

unsigned k;

if (!GSToUnicode(&temp, &temp_length, &pld->ptr[start],

pld->pos - start, NSUTF8StringEncoding,

NSDefaultMallocZone(), 0))

{

pld->err = @"invalid utf8 data while parsing quoted string";

return nil;

}

length = temp_length - shrink;

chars = NSAllocateCollectable(sizeof(unichar) * length, 0);

escaped = 0;

hex = NO;

for (j = 0, k = 0; j < temp_length; j++)

{

unichar c = temp[j];

if (escaped)

{

if (escaped == 1 && c >= '0' && c <= '7')

{

chars[k] = c - '0';

hex = NO;

escaped++;

}

else if (escaped == 1 && (c == 'u' || c == 'U'))

{

chars[k] = 0;

hex = YES;

escaped++;

}

else if (escaped > 1)

{

if (hex && isxdigit(c))

{

chars[k] <<= 4;

chars[k] |= char2num(c);

escaped++;

if (escaped == 6)

{

escaped = 0;

k++;

}

}

else if (c >= '0' && c <= '7')

{

chars[k] <<= 3;

chars[k] |= (c - '0');

escaped++;

if (escaped == 4)

{

escaped = 0;

k++;

}

}

else

{

escaped = 0;

j--;

k++;

}

}

else

{

escaped = 0;

switch (c)

{

case 'a' : chars[k] = '\a'; break;

case 'b' : chars[k] = '\b'; break;

case 't' : chars[k] = '\t'; break;

case 'r' : chars[k] = '\r'; break;

case 'n' : chars[k] = '\n'; break;

case 'v' : chars[k] = '\v'; break;

case 'f' : chars[k] = '\f'; break;

default : chars[k] = c; break;

}

k++;

}

}

else

{

chars[k] = c;

if (c == '\\')

{

escaped = 1;

}

else

{

k++;

}

}

}

NSZoneFree(NSDefaultMallocZone(), temp);

length = k;

if (pld->key == NO

&& pld->opt == NSPropertyListMutableContainersAndLeaves)

{

obj = [GSMutableString alloc];

obj = [obj initWithCharactersNoCopy: chars

length: length

freeWhenDone: YES];

}

else

{

obj = [NSStringClass allocWithZone: NSDefaultMallocZone()];

obj = [obj initWithCharactersNoCopy: chars

length: length

freeWhenDone: YES];

}

}

pld->pos++;

return obj;

}

static inline id parseUnquotedString(pldata *pld)

{

unsigned start = pld->pos;

unsigned i;

unsigned length;

id obj;

unichar *chars;

while (pld->pos < pld->end)

{

if (GS_IS_QUOTABLE(pld->ptr[pld->pos]) == YES)

break;

pld->pos++;

}

length = pld->pos - start;

chars = NSAllocateCollectable(sizeof(unichar) * length, 0);

for (i = 0; i < length; i++)

{

chars[i] = pld->ptr[start + i];

}

if (pld->key == NO

&& pld->opt == NSPropertyListMutableContainersAndLeaves)

{

obj = [GSMutableString alloc];

obj = [obj initWithCharactersNoCopy: chars

length: length

freeWhenDone: YES];

}

else

{

obj = [NSStringClass allocWithZone: NSDefaultMallocZone()];

obj = [obj initWithCharactersNoCopy: chars

length: length

freeWhenDone: YES];

}

return obj;

}

static id parsePlItem(pldata* pld)

{

id result = nil;

BOOL start = (pld->pos == 0 ? YES : NO);

if (skipSpace(pld) == NO)

{

return nil;

}

switch (pld->ptr[pld->pos])

{

case '{':

{

NSMutableDictionary *dict;

dict = [[plDictionary allocWithZone: NSDefaultMallocZone()]

initWithCapacity: 0];

pld->pos++;

while (skipSpace(pld) == YES && pld->ptr[pld->pos] != '}')

{

id key;

id val;

pld->key = YES;

key = parsePlItem(pld);

pld->key = NO;

if (key == nil)

{

return nil;

}

if (skipSpace(pld) == NO)

{

RELEASE(key);

RELEASE(dict);

return nil;

}

if (pld->ptr[pld->pos] != '=')

{

pld->err = @"unexpected character (wanted '=')";

RELEASE(key);

RELEASE(dict);

return nil;

}

pld->pos++;

val = parsePlItem(pld);

if (val == nil)

{

RELEASE(key);

RELEASE(dict);

return nil;

}

if (skipSpace(pld) == NO)

{

RELEASE(key);

RELEASE(val);

RELEASE(dict);

return nil;

}

if (pld->ptr[pld->pos] == ';')

{

pld->pos++;

}

else if (pld->ptr[pld->pos] == '}')

{

if (GSPrivateDefaultsFlag(GSMacOSXCompatible))

{