mirror of
https://github.com/gnustep/libs-base.git
synced 2025-04-25 17:51:01 +00:00
1bfa5baeb9
git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/base/trunk@7480 72102866-910b-0410-8b05-ffd578937521
872 lines
19 KiB
Objective-C
872 lines
19 KiB
Objective-C
/* Text Property-List parsing code for NSString.m and NSGCString.m
|
|
Copyright (C) 1998 Free Software Foundation, Inc.
|
|
|
|
Written by Richard Frith-Macdonald <richard@brainstorm.co.uk>
|
|
Date: October 1998
|
|
|
|
This file is part of the GNUstep Base Library.
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with this library; if not, write to the Free
|
|
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA.
|
|
*/
|
|
|
|
#if HAVE_LIBXML
|
|
#include <Foundation/GSXML.h>
|
|
|
|
static char base64[]
|
|
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
|
|
|
static void
|
|
decodeBase64Unit(const char* ptr, unsigned char *out)
|
|
{
|
|
out[0] = (ptr[0] << 2) | ((ptr[1] & 0x30) >> 4);
|
|
out[1] = ((ptr[1] & 0x0F) << 4) | ((ptr[2] & 0x3C) >> 2);
|
|
out[2] = ((ptr[2] & 0x03) << 6) | (ptr[3] & 0x3F);
|
|
out[3] = 0;
|
|
}
|
|
|
|
static NSData*
|
|
decodeBase64(const char *source)
|
|
{
|
|
int length = strlen(source);
|
|
char *sourceBuffer = objc_malloc(length+1);
|
|
NSMutableData *data = [NSMutableData dataWithCapacity:0];
|
|
int i, j;
|
|
unsigned char tmp[4];
|
|
|
|
strcpy(sourceBuffer, source);
|
|
j = 0;
|
|
|
|
for (i = 0; i < length; i++)
|
|
{
|
|
if (!isspace(source[i]))
|
|
{
|
|
sourceBuffer[j++] = source[i];
|
|
}
|
|
}
|
|
|
|
sourceBuffer[j] = '\0';
|
|
length = strlen(sourceBuffer);
|
|
while (length > 0 && sourceBuffer[length-1] == '=')
|
|
{
|
|
sourceBuffer[--length] = '\0';
|
|
}
|
|
for (i = 0; i < length; i += 4)
|
|
{
|
|
decodeBase64Unit(&sourceBuffer[i], tmp);
|
|
[data appendBytes: tmp length: strlen(tmp)];
|
|
}
|
|
|
|
objc_free(sourceBuffer);
|
|
|
|
return data;
|
|
}
|
|
|
|
|
|
static char*
|
|
encodeBase64(NSData *source)
|
|
{
|
|
int length = [source length];
|
|
int enclen = length / 3;
|
|
int remlen = length - 3 * enclen;
|
|
int destlen = 4 * ((length - 1) / 3) + 5;
|
|
unsigned char *sourceBuffer = malloc(length);
|
|
unsigned char *destBuffer = malloc(destlen);
|
|
int sourceIndex = 0, destIndex = 0;
|
|
|
|
[source getBytes:sourceBuffer];
|
|
destBuffer[destlen - 1] = '\0';
|
|
|
|
for (sourceIndex = 0; sourceIndex < length - 2; sourceIndex += 3, destIndex += 4)
|
|
{
|
|
destBuffer[destIndex] = base64[sourceBuffer[sourceIndex] >> 2];
|
|
destBuffer[destIndex + 1] = base64[((sourceBuffer[sourceIndex] << 4) | (sourceBuffer[sourceIndex + 1] >> 4)) & 0x3f];
|
|
destBuffer[destIndex + 2] = base64[((sourceBuffer[sourceIndex + 1] << 2) | (sourceBuffer[sourceIndex + 2] >> 6)) & 0x3f];
|
|
destBuffer[destIndex + 3] = base64[sourceBuffer[sourceIndex + 2] & 0x3f];
|
|
}
|
|
|
|
if (remlen == 1)
|
|
{
|
|
destBuffer[destIndex] = base64[sourceBuffer[sourceIndex] >> 2];
|
|
destBuffer[destIndex + 1] = (sourceBuffer[sourceIndex] << 4) & 0x30;
|
|
destBuffer[destIndex + 1] = base64[destBuffer[destIndex + 1]];
|
|
destBuffer[destIndex + 2] = '=';
|
|
destBuffer[destIndex + 3] = '=';
|
|
}
|
|
else if (remlen == 2)
|
|
{
|
|
destBuffer[destIndex] = base64[sourceBuffer[sourceIndex] >> 2];
|
|
destBuffer[destIndex + 1] = (sourceBuffer[sourceIndex] << 4) & 0x30;
|
|
destBuffer[destIndex + 1] |= sourceBuffer[sourceIndex + 1] >> 4;
|
|
destBuffer[destIndex + 1] = base64[destBuffer[destIndex + 1]];
|
|
destBuffer[destIndex + 2] = (sourceBuffer[sourceIndex + 1] << 2) & 0x3c;
|
|
destBuffer[destIndex + 2] = base64[destBuffer[destIndex + 2]];
|
|
destBuffer[destIndex + 3] = '=';
|
|
}
|
|
|
|
free(sourceBuffer);
|
|
return destBuffer;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
* Cache some commonly used character sets along with methods to
|
|
* check membership.
|
|
*/
|
|
|
|
static SEL cMemberSel = @selector(characterIsMember:);
|
|
|
|
static NSCharacterSet *hexdigits = nil;
|
|
static BOOL (*hexdigitsImp)(id, SEL, unichar) = 0;
|
|
static void setupHexdigits()
|
|
{
|
|
if (hexdigits == nil)
|
|
{
|
|
hexdigits = [NSCharacterSet characterSetWithCharactersInString:
|
|
@"0123456789abcdef"];
|
|
IF_NO_GC(RETAIN(hexdigits));
|
|
hexdigitsImp =
|
|
(BOOL(*)(id,SEL,unichar)) [hexdigits methodForSelector: cMemberSel];
|
|
}
|
|
}
|
|
|
|
static NSCharacterSet *quotables = nil;
|
|
static BOOL (*quotablesImp)(id, SEL, unichar) = 0;
|
|
static void setupQuotables()
|
|
{
|
|
if (quotables == nil)
|
|
{
|
|
NSMutableCharacterSet *s;
|
|
|
|
s = [[NSCharacterSet characterSetWithCharactersInString:
|
|
@"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz$./_"]
|
|
mutableCopy];
|
|
[s invert];
|
|
quotables = [s copy];
|
|
RELEASE(s);
|
|
quotablesImp =
|
|
(BOOL(*)(id,SEL,unichar)) [quotables methodForSelector: cMemberSel];
|
|
}
|
|
}
|
|
|
|
static NSCharacterSet *whitespce = nil;
|
|
static BOOL (*whitespceImp)(id, SEL, unichar) = 0;
|
|
static void setupWhitespce()
|
|
{
|
|
if (whitespce == nil)
|
|
{
|
|
whitespce = [NSCharacterSet characterSetWithCharactersInString:
|
|
@" \t\r\n\f\b"];
|
|
IF_NO_GC(RETAIN(whitespce));
|
|
whitespceImp =
|
|
(BOOL(*)(id,SEL,unichar)) [whitespce methodForSelector: cMemberSel];
|
|
}
|
|
}
|
|
|
|
@class NSGMutableArray;
|
|
@class NSGMutableDictionary;
|
|
|
|
static Class plCls;
|
|
static Class plArray;
|
|
static id (*plAdd)(id, SEL, id);
|
|
static Class plDictionary;
|
|
static id (*plSet)(id, SEL, id, id);
|
|
static id (*plInit)(id, SEL, void*, unsigned) = 0;
|
|
static id (*plAlloc)(Class, SEL, NSZone*);
|
|
#if GSPLUNI
|
|
static SEL plSel = @selector(initWithCharacters:length:);
|
|
#else
|
|
static SEL plSel = @selector(initWithCString:length:);
|
|
#endif
|
|
|
|
static void setupPl(Class c)
|
|
{
|
|
if (plInit == 0)
|
|
{
|
|
plCls = c;
|
|
plAlloc = (id (*)(id, SEL, NSZone*))
|
|
[c methodForSelector: @selector(allocWithZone:)];
|
|
plInit = (id (*)(id, SEL, void*, unsigned))
|
|
[c instanceMethodForSelector: plSel];
|
|
plArray = [NSGMutableArray class];
|
|
plAdd = (id (*)(id, SEL, id))
|
|
[plArray instanceMethodForSelector: @selector(addObject:)];
|
|
plDictionary = [NSGMutableDictionary class];
|
|
plSet = (id (*)(id, SEL, id, id))
|
|
[plDictionary instanceMethodForSelector: @selector(setObject:forKey:)];
|
|
}
|
|
setupHexdigits();
|
|
setupQuotables();
|
|
setupWhitespce();
|
|
}
|
|
|
|
|
|
#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))
|
|
|
|
typedef struct {
|
|
#if GSPLUNI
|
|
const unichar *ptr;
|
|
#else
|
|
const char *ptr;
|
|
#endif
|
|
unsigned end;
|
|
unsigned pos;
|
|
unsigned lin;
|
|
NSString *err;
|
|
} pldata;
|
|
|
|
/*
|
|
* Property list parsing - skip whitespace keeping count of lines and
|
|
* regarding objective-c style comments as whitespace.
|
|
* Returns YES if there is any non-whitespace text remaining.
|
|
*/
|
|
static BOOL skipSpace(pldata *pld)
|
|
{
|
|
unichar c;
|
|
|
|
while (pld->pos < pld->end)
|
|
{
|
|
c = (unichar)pld->ptr[pld->pos];
|
|
|
|
if ((*whitespceImp)(whitespce, cMemberSel, c) == NO)
|
|
{
|
|
if (c == '/' && pld->pos < pld->end - 1)
|
|
{
|
|
/*
|
|
* Check for comments beginning '/' followed by '/' or '*'
|
|
*/
|
|
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)
|
|
{
|
|
unichar c = (unichar)pld->ptr[pld->pos];
|
|
|
|
if (escaped)
|
|
{
|
|
if (escaped == 1 && c == '0')
|
|
{
|
|
escaped = 2;
|
|
hex = NO;
|
|
}
|
|
else if (escaped > 1)
|
|
{
|
|
if (escaped == 2 && c == 'x')
|
|
{
|
|
hex = YES;
|
|
shrink++;
|
|
escaped++;
|
|
}
|
|
else if (hex && (*hexdigitsImp)(hexdigits, cMemberSel, c))
|
|
{
|
|
shrink++;
|
|
escaped++;
|
|
}
|
|
else if (c >= '0' && c <= '7')
|
|
{
|
|
shrink++;
|
|
escaped++;
|
|
}
|
|
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
|
|
{
|
|
#if GSPLUNI
|
|
unichar chars[pld->pos - start - shrink];
|
|
#else
|
|
char chars[pld->pos - start - shrink];
|
|
#endif
|
|
unsigned j;
|
|
unsigned k;
|
|
|
|
escaped = 0;
|
|
hex = NO;
|
|
for (j = start, k = 0; j < pld->pos; j++)
|
|
{
|
|
unichar c = (unichar)pld->ptr[j];
|
|
|
|
if (escaped)
|
|
{
|
|
if (escaped == 1 && c == '0')
|
|
{
|
|
chars[k] = 0;
|
|
hex = NO;
|
|
escaped++;
|
|
}
|
|
else if (escaped > 1)
|
|
{
|
|
if (escaped == 2 && c == 'x')
|
|
{
|
|
hex = YES;
|
|
escaped++;
|
|
}
|
|
else if (hex && (*hexdigitsImp)(hexdigits, cMemberSel, c))
|
|
{
|
|
chars[k] <<= 4;
|
|
chars[k] |= char2num(c);
|
|
escaped++;
|
|
}
|
|
else if (c >= '0' && c <= '7')
|
|
{
|
|
chars[k] <<= 3;
|
|
chars[k] |= (c - '0');
|
|
escaped++;
|
|
}
|
|
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++;
|
|
}
|
|
}
|
|
}
|
|
obj = (*plAlloc)(plCls, @selector(allocWithZone:), NSDefaultMallocZone());
|
|
obj = (*plInit)(obj, plSel, (void*)chars, pld->pos - start - shrink);
|
|
}
|
|
pld->pos++;
|
|
return obj;
|
|
}
|
|
|
|
static inline id parseUnquotedString(pldata *pld)
|
|
{
|
|
unsigned start = pld->pos;
|
|
id obj;
|
|
|
|
while (pld->pos < pld->end)
|
|
{
|
|
if ((*quotablesImp)(quotables, cMemberSel,
|
|
(unichar)pld->ptr[pld->pos]) == YES)
|
|
break;
|
|
pld->pos++;
|
|
}
|
|
obj = (*plAlloc)(plCls, @selector(allocWithZone:), NSDefaultMallocZone());
|
|
obj = (*plInit)(obj, plSel, (void*)&pld->ptr[start], pld->pos-start);
|
|
return obj;
|
|
}
|
|
|
|
static id parsePlItem(pldata* pld)
|
|
{
|
|
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;
|
|
|
|
key = parsePlItem(pld);
|
|
if (key == nil)
|
|
return nil;
|
|
if (skipSpace(pld) == NO)
|
|
{
|
|
RELEASE(key);
|
|
return nil;
|
|
}
|
|
if (pld->ptr[pld->pos] != '=')
|
|
{
|
|
pld->err = @"unexpected character (wanted '=')";
|
|
RELEASE(key);
|
|
return nil;
|
|
}
|
|
pld->pos++;
|
|
val = parsePlItem(pld);
|
|
if (val == nil)
|
|
{
|
|
RELEASE(key);
|
|
return nil;
|
|
}
|
|
if (skipSpace(pld) == NO)
|
|
{
|
|
RELEASE(key);
|
|
RELEASE(val);
|
|
return nil;
|
|
}
|
|
if (pld->ptr[pld->pos] == ';')
|
|
{
|
|
pld->pos++;
|
|
}
|
|
else if (pld->ptr[pld->pos] != '}')
|
|
{
|
|
pld->err = @"unexpected character (wanted ';' or '}')";
|
|
RELEASE(key);
|
|
RELEASE(val);
|
|
return nil;
|
|
}
|
|
(*plSet)(dict, @selector(setObject:forKey:), val, key);
|
|
RELEASE(key);
|
|
RELEASE(val);
|
|
}
|
|
if (pld->pos >= pld->end)
|
|
{
|
|
pld->err = @"unexpected end of string when parsing dictionary";
|
|
RELEASE(dict);
|
|
return nil;
|
|
}
|
|
pld->pos++;
|
|
return dict;
|
|
}
|
|
|
|
case '(':
|
|
{
|
|
NSMutableArray *array;
|
|
|
|
array = [[plArray allocWithZone: NSDefaultMallocZone()]
|
|
initWithCapacity: 0];
|
|
pld->pos++;
|
|
while (skipSpace(pld) == YES && pld->ptr[pld->pos] != ')')
|
|
{
|
|
id val;
|
|
|
|
val = parsePlItem(pld);
|
|
if (val == nil)
|
|
{
|
|
return nil;
|
|
}
|
|
if (skipSpace(pld) == NO)
|
|
{
|
|
RELEASE(val);
|
|
return nil;
|
|
}
|
|
if (pld->ptr[pld->pos] == ',')
|
|
{
|
|
pld->pos++;
|
|
}
|
|
else if (pld->ptr[pld->pos] != ')')
|
|
{
|
|
pld->err = @"unexpected character (wanted ',' or ')')";
|
|
RELEASE(val);
|
|
return nil;
|
|
}
|
|
(*plAdd)(array, @selector(addObject:), val);
|
|
RELEASE(val);
|
|
}
|
|
if (pld->pos >= pld->end)
|
|
{
|
|
pld->err = @"unexpected end of string when parsing array";
|
|
RELEASE(array);
|
|
return nil;
|
|
}
|
|
pld->pos++;
|
|
return array;
|
|
}
|
|
|
|
case '<':
|
|
{
|
|
NSMutableData *data;
|
|
unsigned max = pld->end - 1;
|
|
unsigned char buf[BUFSIZ];
|
|
unsigned len = 0;
|
|
|
|
data = [[NSMutableData alloc] initWithCapacity: 0];
|
|
pld->pos++;
|
|
while (skipSpace(pld) == YES && pld->ptr[pld->pos] != '>')
|
|
{
|
|
while (pld->pos < max
|
|
&& (*hexdigitsImp)(hexdigits, cMemberSel,
|
|
(unichar)pld->ptr[pld->pos])
|
|
&& (*hexdigitsImp)(hexdigits, cMemberSel,
|
|
(unichar)pld->ptr[pld->pos+1]))
|
|
{
|
|
unsigned char byte;
|
|
|
|
byte = (char2num(pld->ptr[pld->pos])) << 4;
|
|
pld->pos++;
|
|
byte |= char2num(pld->ptr[pld->pos]);
|
|
pld->pos++;
|
|
buf[len++] = byte;
|
|
if (len == sizeof(buf))
|
|
{
|
|
[data appendBytes: buf length: len];
|
|
len = 0;
|
|
}
|
|
}
|
|
}
|
|
if (pld->pos >= pld->end)
|
|
{
|
|
pld->err = @"unexpected end of string when parsing data";
|
|
RELEASE(data);
|
|
return nil;
|
|
}
|
|
if (pld->ptr[pld->pos] != '>')
|
|
{
|
|
pld->err = @"unexpected character in string";
|
|
RELEASE(data);
|
|
return nil;
|
|
}
|
|
if (len > 0)
|
|
{
|
|
[data appendBytes: buf length: len];
|
|
}
|
|
pld->pos++;
|
|
return data;
|
|
}
|
|
|
|
case '"':
|
|
return parseQuotedString(pld);
|
|
|
|
default:
|
|
return parseUnquotedString(pld);
|
|
}
|
|
}
|
|
|
|
#if HAVE_LIBXML
|
|
static GSXMLNode*
|
|
elementNode(GSXMLNode* node)
|
|
{
|
|
while (node != nil)
|
|
{
|
|
if ([node type] == XML_ELEMENT_NODE)
|
|
{
|
|
break;
|
|
}
|
|
node = [node next];
|
|
}
|
|
return node;
|
|
}
|
|
|
|
static id
|
|
nodeToObject(GSXMLNode* node)
|
|
{
|
|
NSString *name;
|
|
NSString *content;
|
|
GSXMLNode *children;
|
|
|
|
node = elementNode(node);
|
|
if (node == nil)
|
|
{
|
|
return nil;
|
|
}
|
|
name = [node name];
|
|
children = elementNode([node children]);
|
|
content = [children content];
|
|
|
|
if ([name isEqualToString: @"string"])
|
|
{
|
|
return content;
|
|
}
|
|
else if ([name isEqualToString: @"key"])
|
|
{
|
|
return content;
|
|
}
|
|
else if ([name isEqualToString: @"true"])
|
|
{
|
|
return [NSNumber numberWithBool: YES];
|
|
}
|
|
else if ([name isEqualToString: @"false"])
|
|
{
|
|
return [NSNumber numberWithBool: NO];
|
|
}
|
|
else if ([name isEqualToString: @"integer"])
|
|
{
|
|
return [NSNumber numberWithInt: [content intValue]];
|
|
}
|
|
else if ([name isEqualToString: @"real"])
|
|
{
|
|
return [NSNumber numberWithDouble: [content doubleValue]];
|
|
}
|
|
else if ([name isEqualToString: @"date"])
|
|
{
|
|
return [NSCalendarDate dateWithString: content
|
|
calendarFormat: @"%Y-%m-%d %H:%M:%S"];
|
|
}
|
|
else if ([name isEqualToString: @"data"])
|
|
{
|
|
return decodeBase64([content cString]);
|
|
}
|
|
// container class
|
|
else if ([name isEqualToString: @"array"])
|
|
{
|
|
NSMutableArray *container = [NSMutableArray array];
|
|
|
|
while (children != nil)
|
|
{
|
|
[container addObject: nodeToObject(children)];
|
|
children = elementNode([children next]);
|
|
}
|
|
return container;
|
|
}
|
|
else if ([name isEqualToString: @"dict"])
|
|
{
|
|
NSMutableDictionary *container = [NSMutableDictionary dictionary];
|
|
|
|
while (children != nil)
|
|
{
|
|
NSString *key = nodeToObject(children);
|
|
|
|
children = elementNode([children next]);
|
|
[container setObject: nodeToObject(children) forKey: key];
|
|
children = elementNode([children next]);
|
|
}
|
|
return container;
|
|
}
|
|
else
|
|
{
|
|
return nil;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static id parsePl(pldata* pld)
|
|
{
|
|
#if HAVE_LIBXML
|
|
while (pld->pos < pld->end && isspace(pld->ptr[pld->pos]))
|
|
{
|
|
pld->pos++;
|
|
}
|
|
/*
|
|
* A string beginning with a '<?' must be an XML file
|
|
*/
|
|
if (pld->pos + 1 < pld->end && pld->ptr[pld->pos] == '<'
|
|
&& pld->ptr[pld->pos+1] == '?')
|
|
{
|
|
NSData *data;
|
|
GSXMLParser *parser;
|
|
char *buf = NSZoneMalloc(NSDefaultMallocZone(), pld->end+1);
|
|
|
|
memcpy(buf, pld->ptr, pld->end);
|
|
buf[pld->end] = '\0';
|
|
data = [NSData dataWithBytesNoCopy: buf length: pld->end+1];
|
|
NSLog(@"Parsing '%s'", buf);
|
|
parser = [GSXMLParser parser: data];
|
|
if ([parser parse] == YES)
|
|
{
|
|
if (![[[[parser doc] root] name] isEqualToString: @"plist"])
|
|
{
|
|
NSLog(@"not a property list - because name node is %@",
|
|
[[[parser doc] root] name]);
|
|
return nil;
|
|
}
|
|
return nodeToObject([[[parser doc] root] children]);
|
|
}
|
|
else
|
|
{
|
|
NSLog(@"not a property list - failed to parse as XML");
|
|
return nil;
|
|
}
|
|
}
|
|
#endif
|
|
return parsePlItem(pld);
|
|
}
|
|
|
|
static id parseSfItem(pldata* pld)
|
|
{
|
|
NSMutableDictionary *dict;
|
|
|
|
dict = [[plDictionary allocWithZone: NSDefaultMallocZone()]
|
|
initWithCapacity: 0];
|
|
while (skipSpace(pld) == YES)
|
|
{
|
|
id key;
|
|
id val;
|
|
|
|
if (pld->ptr[pld->pos] == '"')
|
|
key = parseQuotedString(pld);
|
|
else
|
|
key = parseUnquotedString(pld);
|
|
if (key == nil)
|
|
return nil;
|
|
if (skipSpace(pld) == NO)
|
|
{
|
|
pld->err = @"incomplete final entry (no semicolon?)";
|
|
RELEASE(key);
|
|
return nil;
|
|
}
|
|
if (pld->ptr[pld->pos] == ';')
|
|
{
|
|
pld->pos++;
|
|
(*plSet)(dict, @selector(setObject:forKey:), @"", key);
|
|
RELEASE(key);
|
|
}
|
|
else if (pld->ptr[pld->pos] == '=')
|
|
{
|
|
pld->pos++;
|
|
if (skipSpace(pld) == NO)
|
|
{
|
|
RELEASE(key);
|
|
return nil;
|
|
}
|
|
if (pld->ptr[pld->pos] == '"')
|
|
val = parseQuotedString(pld);
|
|
else
|
|
val = parseUnquotedString(pld);
|
|
if (val == nil)
|
|
{
|
|
RELEASE(key);
|
|
return nil;
|
|
}
|
|
if (skipSpace(pld) == NO)
|
|
{
|
|
pld->err = @"missing final semicolon";
|
|
RELEASE(key);
|
|
RELEASE(val);
|
|
return nil;
|
|
}
|
|
(*plSet)(dict, @selector(setObject:forKey:), val, key);
|
|
RELEASE(key);
|
|
RELEASE(val);
|
|
if (pld->ptr[pld->pos] == ';')
|
|
pld->pos++;
|
|
else
|
|
{
|
|
pld->err = @"unexpected character (wanted ';')";
|
|
RELEASE(dict);
|
|
return nil;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RELEASE(key);
|
|
RELEASE(dict);
|
|
pld->err = @"unexpected character (wanted '=' or ';')";
|
|
return nil;
|
|
}
|
|
}
|
|
return dict;
|
|
}
|