gnustep/libs-base
0
0
Fork 0
mirror of https://github.com/gnustep/libs-base.git synced 2025-05-10 16:20:42 +00:00
Code Issues Projects Releases Packages Wiki Activity

* Source/NSXMLDocument.m:

Browse source 
* Source/NSXMLDTD.m:
* Source/NSXMLNode.m:
* Source/NSXMLDTDNode.m:
* Source/NSXMLElement.m: Remove compiler warnings for clang
reported by David Chisnall.
* Tests/base/NSAutoreleasePool/basic.m: Get to compile again
without -C99.


git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/base/trunk@35043 72102866-910b-0410-8b05-ffd578937521
This commit is contained in:
Fred Kiefer 2012-04-06 22:27:55 +00:00
parent 4bc62f73ee
commit 9629278d59
7 changed files with 320 additions and 299 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
ChangeLog
View file

@ -1,3 +1,14 @@
2012-04-07 Fred Kiefer <FredKiefer@gmx.de>
* Source/NSXMLDocument.m:
* Source/NSXMLDTD.m:
* Source/NSXMLNode.m:
* Source/NSXMLDTDNode.m:
* Source/NSXMLElement.m: Remove compiler warnings for clang
reported by David Chisnall.
* Tests/base/NSAutoreleasePool/basic.m: Get to compile again
without -C99.
2012-04-06 12:37 theraven 2012-04-06 12:37 theraven
* libs/base/trunk/Source/NSConnection.m, * libs/base/trunk/Source/NSConnection.m,
@ -15,7 +26,7 @@
libs/base/trunk/Tests/base/NSArray/basic.m, libs/base/trunk/Tests/base/NSArray/basic.m,
libs/base/trunk/Tests/base/NSDictionary/basic.m: Support for libs/base/trunk/Tests/base/NSDictionary/basic.m: Support for
collection subscripting (NSArray and NSDictionary). collection subscripting (NSArray and NSDictionary).
Yes, the syntax is ugly, but no doubt people will start using it Yes, the syntax is ugly, but no doubt people will start using it
in June... in June...

80
Source/NSXMLDTD.m
View file

@ -57,18 +57,18 @@ GS_PRIVATE_INTERNAL(NSXMLDTD)
- (NSXMLDTDNode*) attributeDeclarationForName: (NSString*)name - (NSXMLDTDNode*) attributeDeclarationForName: (NSString*)name
elementName: (NSString*)elementName elementName: (NSString*)elementName
{ {
xmlDtdPtr node = internal->node; xmlDtdPtr theNode = internal->node;
xmlNodePtr children = NULL; xmlNodePtr children = NULL;
const xmlChar *xmlName = XMLSTRING(name); const xmlChar *xmlName = XMLSTRING(name);
const xmlChar *xmlElementName = XMLSTRING(elementName); const xmlChar *xmlElementName = XMLSTRING(elementName);
if ((node == NULL) || if ((theNode == NULL) ||
(node->children == NULL)) (theNode->children == NULL))
{ {
return nil; return nil;
} }
for (children = node->children; children; children = children->next) for (children = theNode->children; children; children = children->next)
{ {
if (children->type == XML_ATTRIBUTE_DECL) if (children->type == XML_ATTRIBUTE_DECL)
{ {
@ -87,17 +87,17 @@ GS_PRIVATE_INTERNAL(NSXMLDTD)
- (NSXMLDTDNode*) elementDeclarationForName: (NSString*)name - (NSXMLDTDNode*) elementDeclarationForName: (NSString*)name
{ {
xmlDtdPtr node = internal->node; xmlDtdPtr theNode = internal->node;
xmlNodePtr children = NULL; xmlNodePtr children = NULL;
const xmlChar *xmlName = XMLSTRING(name); const xmlChar *xmlName = XMLSTRING(name);
if ((node == NULL) || if ((theNode == NULL) ||
(node->children == NULL)) (theNode->children == NULL))
{ {
return nil; return nil;
} }
for (children = node->children; children; children = children->next) for (children = theNode->children; children; children = children->next)
{ {
if (children->type == XML_ELEMENT_DECL) if (children->type == XML_ELEMENT_DECL)
{ {
@ -116,17 +116,17 @@ GS_PRIVATE_INTERNAL(NSXMLDTD)
- (NSXMLDTDNode*) entityDeclarationForName: (NSString*)name - (NSXMLDTDNode*) entityDeclarationForName: (NSString*)name
{ {
//xmlGetEntityFromDtd //xmlGetEntityFromDtd
xmlDtdPtr node = internal->node; xmlDtdPtr theNode = internal->node;
xmlNodePtr children = NULL; xmlNodePtr children = NULL;
const xmlChar *xmlName = XMLSTRING(name); const xmlChar *xmlName = XMLSTRING(name);
if ((node == NULL) || if ((theNode == NULL) ||
(node->children == NULL)) (theNode->children == NULL))
{ {
return nil; return nil;
} }
for (children = node->children; children; children = children->next) for (children = theNode->children; children; children = children->next)
{ {
if (children->type == XML_ENTITY_DECL) if (children->type == XML_ENTITY_DECL)
{ {
@ -192,36 +192,38 @@ GS_PRIVATE_INTERNAL(NSXMLDTD)
return self; return self;
} }
- (id) initWithKind: (NSXMLNodeKind)kind options: (NSUInteger)theOptions - (id) initWithKind: (NSXMLNodeKind)theKind options: (NSUInteger)theOptions
{ {
if (NSXMLDTDKind == kind) if (NSXMLDTDKind == theKind)
{ {
return [super initWithKind: kind options: theOptions]; return [super initWithKind: theKind options: theOptions];
} }
else else
{ {
[self release]; [self release];
return [[NSXMLNode alloc] initWithKind: kind // This cast is here to keep clang quite that expects an init* method to
options: theOptions]; // return an object of the same class, which is not true here.
return (NSXMLDTD*)[[NSXMLNode alloc] initWithKind: theKind
options: theOptions];
} }
} }
- (void) insertChild: (NSXMLNode*)child atIndex: (NSUInteger)index - (void) insertChild: (NSXMLNode*)child atIndex: (NSUInteger)index
{ {
NSXMLNodeKind kind = [child kind]; NSXMLNodeKind theKind = [child kind];
NSUInteger childCount = [self childCount]; NSUInteger childCount = [self childCount];
// Check to make sure this is a valid addition... // Check to make sure this is a valid addition...
NSAssert(nil != child, NSInvalidArgumentException); NSAssert(nil != child, NSInvalidArgumentException);
NSAssert(index <= childCount, NSInvalidArgumentException); NSAssert(index <= childCount, NSInvalidArgumentException);
NSAssert(nil == [child parent], NSInvalidArgumentException); NSAssert(nil == [child parent], NSInvalidArgumentException);
NSAssert(NSXMLAttributeKind != kind, NSInvalidArgumentException); NSAssert(NSXMLAttributeKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLDTDKind != kind, NSInvalidArgumentException); NSAssert(NSXMLDTDKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLDocumentKind != kind, NSInvalidArgumentException); NSAssert(NSXMLDocumentKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLElementKind != kind, NSInvalidArgumentException); NSAssert(NSXMLElementKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLInvalidKind != kind, NSInvalidArgumentException); NSAssert(NSXMLInvalidKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLNamespaceKind != kind, NSInvalidArgumentException); NSAssert(NSXMLNamespaceKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLTextKind != kind, NSInvalidArgumentException); NSAssert(NSXMLTextKind != theKind, NSInvalidArgumentException);
[self _insertChild: child atIndex: index]; [self _insertChild: child atIndex: index];
} }
@ -239,17 +241,17 @@ GS_PRIVATE_INTERNAL(NSXMLDTD)
- (NSXMLDTDNode*) notationDeclarationForName: (NSString*)name - (NSXMLDTDNode*) notationDeclarationForName: (NSString*)name
{ {
xmlDtdPtr node = internal->node; xmlDtdPtr theNode = internal->node;
xmlNodePtr children = NULL; xmlNodePtr children = NULL;
const xmlChar *xmlName = XMLSTRING(name); const xmlChar *xmlName = XMLSTRING(name);
if ((node == NULL) || if ((theNode == NULL) ||
(node->children == NULL)) (theNode->children == NULL))
{ {
return nil; return nil;
} }
for (children = node->children; children; children = children->next) for (children = theNode->children; children; children = children->next)
{ {
if (children->type == XML_NOTATION_NODE) if (children->type == XML_NOTATION_NODE)
{ {
@ -265,9 +267,9 @@ GS_PRIVATE_INTERNAL(NSXMLDTD)
- (NSString*) publicID - (NSString*) publicID
{ {
xmlDtd *node = internal->node; xmlDtd *theNode = internal->node;
return StringFromXMLStringPtr(node->ExternalID); return StringFromXMLStringPtr(theNode->ExternalID);
} }
- (void) removeChildAtIndex: (NSUInteger)index - (void) removeChildAtIndex: (NSUInteger)index
@ -284,9 +286,9 @@ GS_PRIVATE_INTERNAL(NSXMLDTD)
[child detach]; [child detach];
} }
- (void) replaceChildAtIndex: (NSUInteger)index withNode: (NSXMLNode*)node - (void) replaceChildAtIndex: (NSUInteger)index withNode: (NSXMLNode*)theNode
{ {
[self insertChild: node atIndex: index]; [self insertChild: theNode atIndex: index];
[self removeChildAtIndex: index + 1]; [self removeChildAtIndex: index + 1];
} }
@ -304,23 +306,23 @@ GS_PRIVATE_INTERNAL(NSXMLDTD)
- (void) setPublicID: (NSString*)publicID - (void) setPublicID: (NSString*)publicID
{ {
xmlDtd *node = internal->node; xmlDtd *theNode = internal->node;
node->ExternalID = XMLStringCopy(publicID); theNode->ExternalID = XMLStringCopy(publicID);
} }
- (void) setSystemID: (NSString*)systemID - (void) setSystemID: (NSString*)systemID
{ {
xmlDtd *node = internal->node; xmlDtd *theNode = internal->node;
node->SystemID = XMLStringCopy(systemID); theNode->SystemID = XMLStringCopy(systemID);
} }
- (NSString*) systemID - (NSString*) systemID
{ {
xmlDtd *node = internal->node; xmlDtd *theNode = internal->node;
return StringFromXMLStringPtr(node->SystemID); return StringFromXMLStringPtr(theNode->SystemID);
} }
@end @end

18
Source/NSXMLDTDNode.m
View file

@ -53,19 +53,21 @@ GS_PRIVATE_INTERNAL(NSXMLDTDNode)
GS_CREATE_INTERNAL(NSXMLDTDNode); GS_CREATE_INTERNAL(NSXMLDTDNode);
} }
- (id) initWithKind: (NSXMLNodeKind)kind options: (NSUInteger)theOptions - (id) initWithKind: (NSXMLNodeKind)theKind options: (NSUInteger)theOptions
{ {
if (NSXMLEntityDeclarationKind == kind if (NSXMLEntityDeclarationKind == theKind
|| NSXMLElementDeclarationKind == kind || NSXMLElementDeclarationKind == theKind
|| NSXMLNotationDeclarationKind == kind) || NSXMLNotationDeclarationKind == theKind)
{ {
return [super initWithKind: kind options: theOptions]; return [super initWithKind: theKind options: theOptions];
} }
else else
{ {
[self release]; [self release];
return [[NSXMLNode alloc] initWithKind: kind // This cast is here to keep clang quite that expects an init* method to
options: theOptions]; // return an object of the same class, which is not true here.
return (NSXMLDTDNode*)[[NSXMLNode alloc] initWithKind: theKind
options: theOptions];
} }
} }
@ -79,7 +81,7 @@ GS_PRIVATE_INTERNAL(NSXMLDTDNode)
error: &error]; error: &error];
if (tempDoc != nil) if (tempDoc != nil)
{ {
result = RETAIN([tempDoc childAtIndex: 0]); result = (NSXMLDTDNode*)RETAIN([tempDoc childAtIndex: 0]);
[result detach]; // detach from document. [result detach]; // detach from document.
} }
[tempDoc release]; [tempDoc release];

81
Source/NSXMLDocument.m
View file

@ -120,16 +120,16 @@ GS_PRIVATE_INTERNAL(NSXMLDocument)
{ {
char *url = NULL; char *url = NULL;
char *encoding = NULL; // "UTF8"; char *encoding = NULL; // "UTF8";
int options = XML_PARSE_NOERROR; int xmlOptions = XML_PARSE_NOERROR;
xmlDocPtr doc = NULL; xmlDocPtr doc = NULL;
if (!(mask & NSXMLNodePreserveWhitespace)) if (!(mask & NSXMLNodePreserveWhitespace))
{ {
options |= XML_PARSE_NOBLANKS; xmlOptions |= XML_PARSE_NOBLANKS;
//xmlKeepBlanksDefault(0); //xmlKeepBlanksDefault(0);
} }
doc = xmlReadMemory([data bytes], [data length], doc = xmlReadMemory([data bytes], [data length],
url, encoding, options); url, encoding, xmlOptions);
if (doc == NULL) if (doc == NULL)
{ {
DESTROY(self); DESTROY(self);
@ -155,17 +155,19 @@ GS_PRIVATE_INTERNAL(NSXMLDocument)
return self; return self;
} }
- (id) initWithKind: (NSXMLNodeKind)kind options: (NSUInteger)theOptions - (id) initWithKind: (NSXMLNodeKind)theKind options: (NSUInteger)theOptions
{ {
if (NSXMLDocumentKind == kind) if (NSXMLDocumentKind == theKind)
{ {
return [super initWithKind: kind options: theOptions]; return [super initWithKind: theKind options: theOptions];
} }
else else
{ {
[self release]; [self release];
return [[NSXMLNode alloc] initWithKind: kind // This cast is here to keep clang quite that expects an init* method to
options: theOptions]; // return an object of the same class, which is not true here.
return (NSXMLDocument*)[[NSXMLNode alloc] initWithKind: theKind
options: theOptions];
} }
} }
@ -227,9 +229,9 @@ GS_PRIVATE_INTERNAL(NSXMLDocument)
internal->node->encoding = XMLStringCopy(encoding); internal->node->encoding = XMLStringCopy(encoding);
} }
- (void) setDocumentContentKind: (NSXMLDocumentContentKind)kind - (void) setDocumentContentKind: (NSXMLDocumentContentKind)theContentKind
{ {
internal->contentKind = kind; internal->contentKind = theContentKind;
} }
- (void) setDTD: (NSXMLDTD*)documentTypeDeclaration - (void) setDTD: (NSXMLDTD*)documentTypeDeclaration
@ -246,9 +248,9 @@ GS_PRIVATE_INTERNAL(NSXMLDocument)
[self addChild: documentTypeDeclaration]; [self addChild: documentTypeDeclaration];
} }
- (void) setMIMEType: (NSString*)MIMEType - (void) setMIMEType: (NSString*)theMIMEType
{ {
ASSIGNCOPY(internal->MIMEType, MIMEType); ASSIGNCOPY(internal->MIMEType, theMIMEType);
} }
- (void) setRootElement: (NSXMLNode*)root - (void) setRootElement: (NSXMLNode*)root
@ -282,22 +284,22 @@ GS_PRIVATE_INTERNAL(NSXMLDocument)
- (void) setURI: (NSString*)URI - (void) setURI: (NSString*)URI
{ {
xmlDocPtr node = internal->node; xmlDocPtr theNode = internal->node;
if (node->URL != NULL) if (theNode->URL != NULL)
{ {
xmlFree((xmlChar *)node->URL); xmlFree((xmlChar *)theNode->URL);
} }
node->URL = XMLStringCopy(URI); theNode->URL = XMLStringCopy(URI);
} }
- (NSString*) URI - (NSString*) URI
{ {
xmlDocPtr node = internal->node; xmlDocPtr theNode = internal->node;
if (node->URL) if (theNode->URL)
{ {
return StringFromXMLStringPtr(node->URL); return StringFromXMLStringPtr(theNode->URL);
} }
else else
{ {
@ -309,13 +311,13 @@ GS_PRIVATE_INTERNAL(NSXMLDocument)
{ {
if ([version isEqualToString: @"1.0"] || [version isEqualToString: @"1.1"]) if ([version isEqualToString: @"1.0"] || [version isEqualToString: @"1.1"])
{ {
xmlDocPtr node = internal->node; xmlDocPtr theNode = internal->node;
if (node->version != NULL) if (theNode->version != NULL)
{ {
xmlFree((xmlChar *)node->version); xmlFree((xmlChar *)theNode->version);
} }
node->version = XMLStringCopy(version); theNode->version = XMLStringCopy(version);
} }
else else
{ {
@ -326,32 +328,31 @@ GS_PRIVATE_INTERNAL(NSXMLDocument)
- (NSString*) version - (NSString*) version
{ {
xmlDocPtr node = internal->node; xmlDocPtr theNode = internal->node;
if (node->version) if (theNode->version)
return StringFromXMLStringPtr(node->version); return StringFromXMLStringPtr(theNode->version);
else else
return @"1.0"; return @"1.0";
} }
- (void) insertChild: (NSXMLNode*)child atIndex: (NSUInteger)index - (void) insertChild: (NSXMLNode*)child atIndex: (NSUInteger)index
{ {
NSXMLNodeKind kind = [child kind]; NSXMLNodeKind theKind = [child kind];
NSUInteger childCount = [self childCount]; NSUInteger childCount = [self childCount];
// Check to make sure this is a valid addition... // Check to make sure this is a valid addition...
NSAssert(nil != child, NSInvalidArgumentException); NSAssert(nil != child, NSInvalidArgumentException);
NSAssert(index <= childCount, NSInvalidArgumentException); NSAssert(index <= childCount, NSInvalidArgumentException);
NSAssert(nil == [child parent], NSInvalidArgumentException); NSAssert(nil == [child parent], NSInvalidArgumentException);
kind = [child kind]; NSAssert(NSXMLAttributeKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLAttributeKind != kind, NSInvalidArgumentException); NSAssert(NSXMLDTDKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLDTDKind != kind, NSInvalidArgumentException); NSAssert(NSXMLDocumentKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLDocumentKind != kind, NSInvalidArgumentException); NSAssert(NSXMLElementDeclarationKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLElementDeclarationKind != kind, NSInvalidArgumentException); NSAssert(NSXMLEntityDeclarationKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLEntityDeclarationKind != kind, NSInvalidArgumentException); NSAssert(NSXMLInvalidKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLInvalidKind != kind, NSInvalidArgumentException); NSAssert(NSXMLNamespaceKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLNamespaceKind != kind, NSInvalidArgumentException); NSAssert(NSXMLNotationDeclarationKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLNotationDeclarationKind != kind, NSInvalidArgumentException);
[self _insertChild: child atIndex: index]; [self _insertChild: child atIndex: index];
} }
@ -398,9 +399,9 @@ GS_PRIVATE_INTERNAL(NSXMLDocument)
[self insertChild: child atIndex: [self childCount]]; [self insertChild: child atIndex: [self childCount]];
} }
- (void) replaceChildAtIndex: (NSUInteger)index withNode: (NSXMLNode*)node - (void) replaceChildAtIndex: (NSUInteger)index withNode: (NSXMLNode*)theNode
{ {
[self insertChild: node atIndex: index]; [self insertChild: theNode atIndex: index];
[self removeChildAtIndex: index + 1]; [self removeChildAtIndex: index + 1];
} }
@ -409,9 +410,9 @@ GS_PRIVATE_INTERNAL(NSXMLDocument)
return [self XMLDataWithOptions: NSXMLNodeOptionsNone]; return [self XMLDataWithOptions: NSXMLNodeOptionsNone];
} }
- (NSData *) XMLDataWithOptions: (NSUInteger)options - (NSData *) XMLDataWithOptions: (NSUInteger)theOptions
{ {
NSString *xmlString = [self XMLStringWithOptions: options]; NSString *xmlString = [self XMLStringWithOptions: theOptions];
return [xmlString dataUsingEncoding: NSUTF8StringEncoding return [xmlString dataUsingEncoding: NSUTF8StringEncoding
allowLossyConversion: NO]; allowLossyConversion: NO];

126
Source/NSXMLElement.m
View file

@ -70,17 +70,19 @@ extern void ensure_oldNs(xmlNodePtr node);
return [self initWithKind: NSXMLElementKind options: 0]; return [self initWithKind: NSXMLElementKind options: 0];
} }
- (id) initWithKind: (NSXMLNodeKind)kind options: (NSUInteger)theOptions - (id) initWithKind: (NSXMLNodeKind)theKind options: (NSUInteger)theOptions
{ {
if (NSXMLElementKind == kind) if (NSXMLElementKind == theKind)
{ {
return [super initWithKind: kind options: theOptions]; return [super initWithKind: theKind options: theOptions];
} }
else else
{ {
[self release]; [self release];
return [[NSXMLNode alloc] initWithKind: kind // This cast is here to keep clang quite that expects an init* method to
options: theOptions]; // return an object of the same class, which is not true here.
return (NSXMLElement*)[[NSXMLNode alloc] initWithKind: theKind
options: theOptions];
} }
} }
@ -176,8 +178,8 @@ extern void ensure_oldNs(xmlNodePtr node);
((cur->ns == NULL) || (cur->ns->prefix == NULL) || ((cur->ns == NULL) || (cur->ns->prefix == NULL) ||
(xmlStrcmp(cur->ns->prefix, (const xmlChar*)"") == 0))) (xmlStrcmp(cur->ns->prefix, (const xmlChar*)"") == 0)))
{ {
NSXMLNode *node = [NSXMLNode _objectForNode: cur]; NSXMLNode *theNode = [NSXMLNode _objectForNode: cur];
[results addObject: node]; [results addObject: theNode];
} }
} }
} }
@ -214,8 +216,8 @@ extern void ensure_oldNs(xmlNodePtr node);
(xmlStrcmp(childNS->prefix, (const xmlChar*)"") == 0)))) || (xmlStrcmp(childNS->prefix, (const xmlChar*)"") == 0)))) ||
((cur->ns != NULL) && (xmlStrcmp(cur->ns->href, href) == 0))) ((cur->ns != NULL) && (xmlStrcmp(cur->ns->href, href) == 0)))
{ {
NSXMLNode *node = [NSXMLNode _objectForNode: cur]; NSXMLNode *theNode = [NSXMLNode _objectForNode: cur];
[results addObject: node]; [results addObject: theNode];
} }
} }
} }
@ -226,7 +228,7 @@ extern void ensure_oldNs(xmlNodePtr node);
- (void) addAttribute: (NSXMLNode*)attribute - (void) addAttribute: (NSXMLNode*)attribute
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
xmlAttrPtr attr = (xmlAttrPtr)[attribute _node]; xmlAttrPtr attr = (xmlAttrPtr)[attribute _node];
xmlAttrPtr oldAttr; xmlAttrPtr oldAttr;
@ -244,7 +246,7 @@ extern void ensure_oldNs(xmlNodePtr node);
if (ns->href == NULL) if (ns->href == NULL)
{ {
xmlNsPtr newNs = xmlSearchNs(node->doc, node, ns->prefix); xmlNsPtr newNs = xmlSearchNs(theNode->doc, theNode, ns->prefix);
if (newNs != NULL) if (newNs != NULL)
{ {
@ -255,7 +257,7 @@ extern void ensure_oldNs(xmlNodePtr node);
} }
else //if (ns->prefix == NULL) else //if (ns->prefix == NULL)
{ {
xmlNsPtr newNs = xmlSearchNsByHref(node->doc, node, ns->href); xmlNsPtr newNs = xmlSearchNsByHref(theNode->doc, theNode, ns->href);
if (newNs != NULL) if (newNs != NULL)
{ {
@ -292,8 +294,8 @@ extern void ensure_oldNs(xmlNodePtr node);
} }
// Insert in new // Insert in new
ensure_oldNs(node); ensure_oldNs(theNode);
oldNs1 = node->doc->oldNs; oldNs1 = theNode->doc->oldNs;
while (oldNs1) while (oldNs1)
{ {
if (oldNs1->next == NULL) if (oldNs1->next == NULL)
@ -307,17 +309,17 @@ extern void ensure_oldNs(xmlNodePtr node);
#if LIBXML_VERSION >= 20620 #if LIBXML_VERSION >= 20620
xmlDOMWrapAdoptNode(NULL, attr->doc, (xmlNodePtr)attr, xmlDOMWrapAdoptNode(NULL, attr->doc, (xmlNodePtr)attr,
node->doc, node, 0); theNode->doc, theNode, 0);
#else #else
xmlSetTreeDoc((xmlNodePtr)attr, node->doc); xmlSetTreeDoc((xmlNodePtr)attr, theNode->doc);
#endif #endif
xmlFreeDoc(tmp); xmlFreeDoc(tmp);
oldAttr = xmlHasNsProp(node, attr->name, ns->href); oldAttr = xmlHasNsProp(theNode, attr->name, ns->href);
} }
else else
{ {
oldAttr = xmlHasProp(node, attr->name); oldAttr = xmlHasProp(theNode, attr->name);
} }
if (NULL != oldAttr) if (NULL != oldAttr)
@ -344,7 +346,7 @@ extern void ensure_oldNs(xmlNodePtr node);
} }
} }
} }
xmlAddChild(node, (xmlNodePtr)attr); xmlAddChild(theNode, (xmlNodePtr)attr);
[self _addSubNode: attribute]; [self _addSubNode: attribute];
} }
@ -390,8 +392,8 @@ extern void ensure_oldNs(xmlNodePtr node);
- (NSArray*) attributes - (NSArray*) attributes
{ {
NSMutableArray *attributes = [NSMutableArray array]; NSMutableArray *attributes = [NSMutableArray array];
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
xmlAttrPtr attributeNode = node->properties; xmlAttrPtr attributeNode = theNode->properties;
while (attributeNode) while (attributeNode)
{ {
@ -423,8 +425,8 @@ extern void ensure_oldNs(xmlNodePtr node);
{ {
NSXMLNode *result = nil; NSXMLNode *result = nil;
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
xmlAttrPtr attributeNode = xmlHasProp(node, XMLSTRING(name)); xmlAttrPtr attributeNode = xmlHasProp(theNode, XMLSTRING(name));
if (NULL != attributeNode) if (NULL != attributeNode)
{ {
@ -439,8 +441,8 @@ extern void ensure_oldNs(xmlNodePtr node);
URI: (NSString*)URI URI: (NSString*)URI
{ {
NSXMLNode *result = nil; NSXMLNode *result = nil;
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
xmlAttrPtr attributeNode = xmlHasNsProp(node, XMLSTRING(localName), xmlAttrPtr attributeNode = xmlHasNsProp(theNode, XMLSTRING(localName),
XMLSTRING(URI)); XMLSTRING(URI));
if (NULL != attributeNode) if (NULL != attributeNode)
@ -454,16 +456,16 @@ extern void ensure_oldNs(xmlNodePtr node);
- (void) addNamespace: (NSXMLNode*)aNamespace - (void) addNamespace: (NSXMLNode*)aNamespace
{ {
xmlNsPtr ns = xmlCopyNamespace((xmlNsPtr)[aNamespace _node]); xmlNsPtr ns = xmlCopyNamespace((xmlNsPtr)[aNamespace _node]);
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
const xmlChar *prefix = ns->prefix; const xmlChar *prefix = ns->prefix;
if (node->nsDef == NULL) if (theNode->nsDef == NULL)
{ {
node->nsDef = ns; theNode->nsDef = ns;
} }
else else
{ {
xmlNsPtr cur = node->nsDef; xmlNsPtr cur = theNode->nsDef;
xmlNsPtr last = NULL; xmlNsPtr last = NULL;
while (cur != NULL) while (cur != NULL)
@ -487,13 +489,13 @@ extern void ensure_oldNs(xmlNodePtr node);
if (cur->href == NULL) if (cur->href == NULL)
{ {
// This was a fake namespace we added // This was a fake namespace we added
if (node->ns == cur) if (theNode->ns == cur)
{ {
node->ns = ns; theNode->ns = ns;
} }
if (last == NULL) if (last == NULL)
{ {
node->nsDef = ns; theNode->nsDef = ns;
} }
else else
{ {
@ -505,22 +507,22 @@ extern void ensure_oldNs(xmlNodePtr node);
} }
// Are we setting a default namespace? // Are we setting a default namespace?
if ((node->ns == NULL) && (xmlStrcmp(prefix, (const xmlChar*)"") == 0)) if ((theNode->ns == NULL) && (xmlStrcmp(prefix, (const xmlChar*)"") == 0))
{ {
node->ns = ns; theNode->ns = ns;
} }
// Need to replace fake namespaces in subnodes // Need to replace fake namespaces in subnodes
cleanup_namespaces(node, ns); cleanup_namespaces(theNode, ns);
} }
- (void) removeNamespaceForPrefix: (NSString*)name - (void) removeNamespaceForPrefix: (NSString*)name
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (node->nsDef != NULL) if (theNode->nsDef != NULL)
{ {
xmlNsPtr cur = node->nsDef; xmlNsPtr cur = theNode->nsDef;
xmlNsPtr last = NULL; xmlNsPtr last = NULL;
const xmlChar *prefix = XMLSTRING(name); const xmlChar *prefix = XMLSTRING(name);
@ -538,9 +540,9 @@ extern void ensure_oldNs(xmlNodePtr node);
last->next = cur->next; last->next = cur->next;
} }
cur->next = NULL; cur->next = NULL;
if (node->ns == cur) if (theNode->ns == cur)
{ {
node->ns = NULL; theNode->ns = NULL;
} }
xmlFreeNs(cur); xmlFreeNs(cur);
return; return;
@ -593,14 +595,14 @@ extern void ensure_oldNs(xmlNodePtr node);
if (name != nil) if (name != nil)
{ {
const xmlChar *prefix = XMLSTRING(name); const xmlChar *prefix = XMLSTRING(name);
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
xmlNsPtr ns; xmlNsPtr ns;
ns = xmlSearchNs(node->doc, node, prefix); ns = xmlSearchNs(theNode->doc, theNode, prefix);
if ((ns == NULL) && ([name length] == 0)) if ((ns == NULL) && ([name length] == 0))
{ {
prefix = NULL; prefix = NULL;
ns = xmlSearchNs(node->doc, node, prefix); ns = xmlSearchNs(theNode->doc, theNode, prefix);
} }
if (ns != NULL) if (ns != NULL)
@ -640,21 +642,21 @@ extern void ensure_oldNs(xmlNodePtr node);
- (void) insertChild: (NSXMLNode*)child atIndex: (NSUInteger)index - (void) insertChild: (NSXMLNode*)child atIndex: (NSUInteger)index
{ {
NSXMLNodeKind kind = [child kind]; NSXMLNodeKind theKind = [child kind];
NSUInteger childCount = [self childCount]; NSUInteger childCount = [self childCount];
// Check to make sure this is a valid addition... // Check to make sure this is a valid addition...
NSAssert(nil != child, NSInvalidArgumentException); NSAssert(nil != child, NSInvalidArgumentException);
NSAssert(index <= childCount, NSInvalidArgumentException); NSAssert(index <= childCount, NSInvalidArgumentException);
NSAssert(nil == [child parent], NSInvalidArgumentException); NSAssert(nil == [child parent], NSInvalidArgumentException);
NSAssert(NSXMLAttributeKind != kind, NSInvalidArgumentException); NSAssert(NSXMLAttributeKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLDTDKind != kind, NSInvalidArgumentException); NSAssert(NSXMLDTDKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLDocumentKind != kind, NSInvalidArgumentException); NSAssert(NSXMLDocumentKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLElementDeclarationKind != kind, NSInvalidArgumentException); NSAssert(NSXMLElementDeclarationKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLEntityDeclarationKind != kind, NSInvalidArgumentException); NSAssert(NSXMLEntityDeclarationKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLInvalidKind != kind, NSInvalidArgumentException); NSAssert(NSXMLInvalidKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLNamespaceKind != kind, NSInvalidArgumentException); NSAssert(NSXMLNamespaceKind != theKind, NSInvalidArgumentException);
NSAssert(NSXMLNotationDeclarationKind != kind, NSInvalidArgumentException); NSAssert(NSXMLNotationDeclarationKind != theKind, NSInvalidArgumentException);
[self _insertChild: child atIndex: index]; [self _insertChild: child atIndex: index];
} }
@ -701,9 +703,9 @@ extern void ensure_oldNs(xmlNodePtr node);
[self insertChild: child atIndex: [self childCount]]; [self insertChild: child atIndex: [self childCount]];
} }
- (void) replaceChildAtIndex: (NSUInteger)index withNode: (NSXMLNode*)node - (void) replaceChildAtIndex: (NSUInteger)index withNode: (NSXMLNode*)theNode
{ {
[self insertChild: node atIndex: index]; [self insertChild: theNode atIndex: index];
[self removeChildAtIndex: index + 1]; [self removeChildAtIndex: index + 1];
} }
@ -740,23 +742,23 @@ joinTextNodes(xmlNodePtr nodeA, xmlNodePtr nodeB, NSMutableArray *nodesToDelete)
while ((subNode = [subEnum nextObject])) while ((subNode = [subEnum nextObject]))
{ {
xmlNodePtr node = [subNode _node]; xmlNodePtr theNode = [subNode _node];
xmlNodePtr prev = node->prev; xmlNodePtr prev = theNode->prev;
xmlNodePtr next = node->next; xmlNodePtr next = theNode->next;
if (node->type == XML_ELEMENT_NODE) if (theNode->type == XML_ELEMENT_NODE)
{ {
[(NSXMLElement *)subNode [(NSXMLElement *)subNode
normalizeAdjacentTextNodesPreservingCDATA:preserve]; normalizeAdjacentTextNodesPreservingCDATA:preserve];
} }
else if (node->type == XML_TEXT_NODE else if (theNode->type == XML_TEXT_NODE
|| (node->type == XML_CDATA_SECTION_NODE && !preserve)) || (theNode->type == XML_CDATA_SECTION_NODE && !preserve))
{ {
if (next && (next->type == XML_TEXT_NODE if (next && (next->type == XML_TEXT_NODE
|| (next->type == XML_CDATA_SECTION_NODE && !preserve))) || (next->type == XML_CDATA_SECTION_NODE && !preserve)))
{ {
//combine node & node->next //combine node & node->next
joinTextNodes(node, node->next, nodesToDelete); joinTextNodes(theNode, theNode->next, nodesToDelete);
} }
if (prev && (prev->type == XML_TEXT_NODE if (prev && (prev->type == XML_TEXT_NODE
|| (prev->type == XML_CDATA_SECTION_NODE && !preserve))) || (prev->type == XML_CDATA_SECTION_NODE && !preserve)))
@ -772,7 +774,7 @@ joinTextNodes(xmlNodePtr nodeA, xmlNodePtr nodeB, NSMutableArray *nodesToDelete)
* from our subNodes when we're done iterating it) * from our subNodes when we're done iterating it)
* (or maybe we need to turn it into an NSInvalidNode too??) * (or maybe we need to turn it into an NSInvalidNode too??)
*/ */
joinTextNodes(node->prev, node, nodesToDelete); joinTextNodes(theNode->prev, theNode, nodesToDelete);
} }
} }

295
Source/NSXMLNode.m
View file

@ -470,13 +470,13 @@ isEqualTree(xmlNodePtr nodeA, xmlNodePtr nodeB)
GS_CREATE_INTERNAL(NSXMLNode); GS_CREATE_INTERNAL(NSXMLNode);
} }
- (id) _initWithNode: (xmlNodePtr)node kind: (NSXMLNodeKind)kind - (id) _initWithNode: (xmlNodePtr)theNode kind: (NSXMLNodeKind)theKind
{ {
if ((self = [super init])) if ((self = [super init]))
{ {
[self _createInternal]; [self _createInternal];
[self _setNode: node]; [self _setNode: theNode];
internal->kind = kind; internal->kind = theKind;
} }
return self; return self;
} }
@ -484,16 +484,16 @@ isEqualTree(xmlNodePtr nodeA, xmlNodePtr nodeB)
- (xmlNodePtr) _childNodeAtIndex: (NSUInteger)index - (xmlNodePtr) _childNodeAtIndex: (NSUInteger)index
{ {
NSUInteger count = 0; NSUInteger count = 0;
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
xmlNodePtr children; xmlNodePtr children;
if ((node->type == XML_NAMESPACE_DECL) || if ((theNode->type == XML_NAMESPACE_DECL) ||
(node->type == XML_ATTRIBUTE_NODE)) (theNode->type == XML_ATTRIBUTE_NODE))
{ {
return NULL; return NULL;
} }
children = node->children; children = theNode->children;
if (!children) if (!children)
return NULL; // the Cocoa docs say it returns nil if there are no children return NULL; // the Cocoa docs say it returns nil if there are no children
@ -1096,20 +1096,20 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
{ {
NSUInteger count = 0; NSUInteger count = 0;
xmlNodePtr children = NULL; xmlNodePtr children = NULL;
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (!node) if (!theNode)
{ {
return 0; return 0;
} }
if ((node->type == XML_NAMESPACE_DECL) || if ((theNode->type == XML_NAMESPACE_DECL) ||
(node->type == XML_ATTRIBUTE_NODE)) (theNode->type == XML_ATTRIBUTE_NODE))
{ {
return 0; return 0;
} }
for (children = node->children; children; children = children->next) for (children = theNode->children; children; children = children->next)
{ {
count++; count++;
} }
@ -1128,18 +1128,18 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
else else
{ {
xmlNodePtr children = NULL; xmlNodePtr children = NULL;
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if ((node == NULL) || if ((theNode == NULL) ||
(node->type == XML_NAMESPACE_DECL) || (theNode->type == XML_NAMESPACE_DECL) ||
(node->type == XML_ATTRIBUTE_NODE) || (theNode->type == XML_ATTRIBUTE_NODE) ||
(node->children == NULL)) (theNode->children == NULL))
{ {
return nil; return nil;
} }
childrenArray = [NSMutableArray array]; childrenArray = [NSMutableArray array];
for (children = node->children; children; children = children->next) for (children = theNode->children; children; children = children->next)
{ {
NSXMLNode *n = [NSXMLNode _objectForNode: children]; NSXMLNode *n = [NSXMLNode _objectForNode: children];
[childrenArray addObject: n]; [childrenArray addObject: n];
@ -1186,49 +1186,49 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
{ {
if (GS_EXISTS_INTERNAL) if (GS_EXISTS_INTERNAL)
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
NSArray *subNodes = [internal->subNodes copy]; NSArray *theSubNodes = [internal->subNodes copy];
NSEnumerator *enumerator = [subNodes objectEnumerator]; NSEnumerator *enumerator = [theSubNodes objectEnumerator];
NSXMLNode *subNode; NSXMLNode *subNode;
while ((subNode = [enumerator nextObject]) != nil) while ((subNode = [enumerator nextObject]) != nil)
{ {
[subNode detach]; [subNode detach];
} }
[subNodes release]; [theSubNodes release];
[internal->objectValue release]; [internal->objectValue release];
[internal->subNodes release]; [internal->subNodes release];
if (node) if (theNode)
{ {
if (node->type == XML_NAMESPACE_DECL) if (theNode->type == XML_NAMESPACE_DECL)
{ {
((xmlNsPtr)node)->_private = NULL; ((xmlNsPtr)theNode)->_private = NULL;
// FIXME: Not sure when to free the node here, // FIXME: Not sure when to free the node here,
// the same namespace node might be referenced // the same namespace node might be referenced
// from other places. // from other places.
xmlFreeNode(node); xmlFreeNode(theNode);
} }
else else
{ {
node->_private = NULL; theNode->_private = NULL;
if (node->parent == NULL) if (theNode->parent == NULL)
{ {
// the top level node frees the entire tree // the top level node frees the entire tree
if (node->type == XML_DOCUMENT_NODE) if (theNode->type == XML_DOCUMENT_NODE)
{ {
xmlFreeDoc((xmlDocPtr)node); xmlFreeDoc((xmlDocPtr)theNode);
} }
else if (node->type == XML_ENTITY_DECL && else if (theNode->type == XML_ENTITY_DECL &&
((xmlEntityPtr)node)->etype == XML_INTERNAL_PREDEFINED_ENTITY) ((xmlEntityPtr)theNode)->etype == XML_INTERNAL_PREDEFINED_ENTITY)
{ {
// Don't free internal entity nodes // Don't free internal entity nodes
} }
else else
{ {
xmlDocPtr tmp = node->doc; xmlDocPtr tmp = theNode->doc;
xmlFreeNode(node); xmlFreeNode(theNode);
// Free the private document we allocated in detach // Free the private document we allocated in detach
if (tmp) if (tmp)
{ {
@ -1245,19 +1245,19 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
- (void) detach - (void) detach
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (node) if (theNode)
{ {
NSXMLNode *parent = [self parent]; NSXMLNode *parent = [self parent];
if (node->type == XML_NAMESPACE_DECL) if (theNode->type == XML_NAMESPACE_DECL)
{ {
// FIXME // FIXME
} }
else else
{ {
if (node->doc) if (theNode->doc)
{ {
/* Create a private document and move the node over. /* Create a private document and move the node over.
* This is needed so that the strings of the nodes subtree * This is needed so that the strings of the nodes subtree
@ -1268,15 +1268,15 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
xmlDocPtr tmp = xmlNewDoc((xmlChar *)"1.0"); xmlDocPtr tmp = xmlNewDoc((xmlChar *)"1.0");
#if LIBXML_VERSION >= 20620 #if LIBXML_VERSION >= 20620
xmlDOMWrapAdoptNode(NULL, node->doc, node, tmp, NULL, 0); xmlDOMWrapAdoptNode(NULL, theNode->doc, theNode, tmp, NULL, 0);
#else #else
xmlSetTreeDoc(node, tmp); xmlSetTreeDoc(theNode, tmp);
#endif #endif
} }
else else
{ {
// separate our node from its parent and siblings // separate our node from its parent and siblings
xmlUnlinkNode(node); xmlUnlinkNode(theNode);
} }
} }
@ -1294,15 +1294,15 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
- (NSUInteger) index - (NSUInteger) index
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
int count = 0; int count = 0;
if (node->type == XML_NAMESPACE_DECL) if (theNode->type == XML_NAMESPACE_DECL)
{ {
return 0; return 0;
} }
while ((node = node->prev)) while ((theNode = theNode->prev))
{ {
count++; // count our earlier sibling nodes count++; // count our earlier sibling nodes
} }
@ -1315,20 +1315,20 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
return [self initWithKind: NSXMLInvalidKind]; return [self initWithKind: NSXMLInvalidKind];
} }
- (id) initWithKind: (NSXMLNodeKind) kind - (id) initWithKind: (NSXMLNodeKind)theKind
{ {
return [self initWithKind: kind options: 0]; return [self initWithKind: theKind options: 0];
} }
- (id) initWithKind: (NSXMLNodeKind)kind options: (NSUInteger)theOptions - (id) initWithKind: (NSXMLNodeKind)theKind options: (NSUInteger)theOptions
{ {
Class theSubclass = [NSXMLNode class]; Class theSubclass = [NSXMLNode class];
void *node = NULL; void *theNode = NULL;
/* /*
* We find the correct subclass for specific node kinds: * We find the correct subclass for specific node kinds:
*/ */
switch (kind) switch (theKind)
{ {
case NSXMLDocumentKind: case NSXMLDocumentKind:
theSubclass = [NSXMLDocument class]; theSubclass = [NSXMLDocument class];
@ -1367,7 +1367,7 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
return nil; return nil;
default: default:
kind = NSXMLInvalidKind; theKind = NSXMLInvalidKind;
theSubclass = [NSXMLNode class]; theSubclass = [NSXMLNode class];
break; break;
} }
@ -1380,26 +1380,26 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
if (NO == [self isKindOfClass: theSubclass]) if (NO == [self isKindOfClass: theSubclass])
{ {
[self release]; [self release];
return [[theSubclass alloc] initWithKind: kind return [[theSubclass alloc] initWithKind: theKind
options: theOptions]; options: theOptions];
} }
/* If we are initializing for the correct class, we can actually perform /* If we are initializing for the correct class, we can actually perform
* initializations: * initializations:
*/ */
switch (kind) switch (theKind)
{ {
case NSXMLDocumentKind: case NSXMLDocumentKind:
node = xmlNewDoc((xmlChar *)"1.0"); theNode = xmlNewDoc((xmlChar *)"1.0");
break; break;
case NSXMLInvalidKind: case NSXMLInvalidKind:
case NSXMLElementKind: case NSXMLElementKind:
node = xmlNewNode(NULL,(xmlChar *)""); theNode = xmlNewNode(NULL,(xmlChar *)"");
break; break;
case NSXMLDTDKind: case NSXMLDTDKind:
node = xmlNewDtd(NULL, (xmlChar *)"", (xmlChar *)"",(xmlChar *)""); theNode = xmlNewDtd(NULL, (xmlChar *)"", (xmlChar *)"",(xmlChar *)"");
break; break;
case NSXMLElementDeclarationKind: case NSXMLElementDeclarationKind:
@ -1409,14 +1409,14 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
memset(ret, 0, sizeof(xmlElement)); memset(ret, 0, sizeof(xmlElement));
ret->type = XML_ELEMENT_DECL; ret->type = XML_ELEMENT_DECL;
ret->name = xmlStrdup((xmlChar *)""); ret->name = xmlStrdup((xmlChar *)"");
node = ret; theNode = ret;
break; break;
} }
case NSXMLEntityDeclarationKind: case NSXMLEntityDeclarationKind:
#if LIBXML_VERSION >= 20700 #if LIBXML_VERSION >= 20700
node = xmlNewEntity(NULL, (xmlChar *)"", 0, (xmlChar *)"", theNode = xmlNewEntity(NULL, (xmlChar *)"", 0, (xmlChar *)"",
(xmlChar *)"", (xmlChar *)""); (xmlChar *)"", (xmlChar *)"");
#else #else
{ {
xmlEntityPtr ret; xmlEntityPtr ret;
@ -1427,41 +1427,41 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
ret->ExternalID = xmlStrdup((xmlChar *)""); ret->ExternalID = xmlStrdup((xmlChar *)"");
ret->SystemID = xmlStrdup((xmlChar *)""); ret->SystemID = xmlStrdup((xmlChar *)"");
ret->content = xmlStrdup((xmlChar *)""); ret->content = xmlStrdup((xmlChar *)"");
node = ret; theNode = ret;
} }
#endif #endif
break; break;
case NSXMLNotationDeclarationKind: case NSXMLNotationDeclarationKind:
// FIXME // FIXME
node = xmlNewNode(NULL, (xmlChar *)""); theNode = xmlNewNode(NULL, (xmlChar *)"");
break; break;
case NSXMLProcessingInstructionKind: case NSXMLProcessingInstructionKind:
node = xmlNewPI((xmlChar *)"", (xmlChar *)""); theNode = xmlNewPI((xmlChar *)"", (xmlChar *)"");
break; break;
case NSXMLCommentKind: case NSXMLCommentKind:
node = xmlNewComment((xmlChar *)""); theNode = xmlNewComment((xmlChar *)"");
break; break;
case NSXMLTextKind: case NSXMLTextKind:
node = xmlNewText((xmlChar *)""); theNode = xmlNewText((xmlChar *)"");
break; break;
case NSXMLNamespaceKind: case NSXMLNamespaceKind:
node = xmlNewNs(NULL,(xmlChar *)"",(xmlChar *)""); theNode = xmlNewNs(NULL,(xmlChar *)"",(xmlChar *)"");
break; break;
case NSXMLAttributeKind: case NSXMLAttributeKind:
node = xmlNewProp(NULL,(xmlChar *)"",(xmlChar *)""); theNode = xmlNewProp(NULL,(xmlChar *)"",(xmlChar *)"");
break; break;
default: default:
break; break;
} }
if (nil == (self = [self _initWithNode: node kind: kind])) if (nil == (self = [self _initWithNode: theNode kind: theKind]))
{ {
return nil; return nil;
} }
@ -1505,20 +1505,20 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
- (NSString*) localName - (NSString*) localName
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (NSXMLInvalidKind == internal->kind) if (NSXMLInvalidKind == internal->kind)
{ {
return nil; return nil;
} }
if (node->type == XML_NAMESPACE_DECL) if (theNode->type == XML_NAMESPACE_DECL)
{ {
return StringFromXMLStringPtr(((xmlNs *)node)->prefix); return StringFromXMLStringPtr(((xmlNs *)theNode)->prefix);
} }
else else
{ {
return StringFromXMLStringPtr(node->name); return StringFromXMLStringPtr(theNode->name);
} }
} }
@ -1543,7 +1543,7 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
{ {
NSXMLNode *ancestor = self; NSXMLNode *ancestor = self;
NSXMLNode *candidate = nil; NSXMLNode *candidate = nil;
NSXMLNodeKind kind; NSXMLNodeKind theKind;
if (forward) if (forward)
{ {
@ -1588,8 +1588,8 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
} }
/* Sanity check: Namespace and attribute nodes are skipped: */ /* Sanity check: Namespace and attribute nodes are skipped: */
kind = [candidate kind]; theKind = [candidate kind];
if ((NSXMLAttributeKind == kind) || (NSXMLNamespaceKind == kind)) if ((NSXMLAttributeKind == theKind) || (NSXMLNamespaceKind == theKind))
{ {
return [candidate _nodeFollowingInNaturalDirection: forward]; return [candidate _nodeFollowingInNaturalDirection: forward];
} }
@ -1603,17 +1603,17 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
- (NSXMLNode*) nextSibling - (NSXMLNode*) nextSibling
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (NULL == node) if (NULL == theNode)
{ {
return nil; return nil;
} }
if (XML_NAMESPACE_DECL == node->type) if (XML_NAMESPACE_DECL == theNode->type)
{ {
return nil; return nil;
} }
return [NSXMLNode _objectForNode: node->next]; return [NSXMLNode _objectForNode: theNode->next];
} }
- (id) objectValue - (id) objectValue
@ -1624,43 +1624,43 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
- (NSXMLNode*) parent - (NSXMLNode*) parent
{ {
xmlNodePtr parent = NULL; xmlNodePtr parent = NULL;
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (NULL == node) if (NULL == theNode)
{ {
return nil; return nil;
} }
if (XML_NAMESPACE_DECL == node->type) if (XML_NAMESPACE_DECL == theNode->type)
{ {
return nil; return nil;
} }
parent = node->parent; parent = theNode->parent;
return [NSXMLNode _objectForNode: parent]; return [NSXMLNode _objectForNode: parent];
} }
- (NSString*) prefix - (NSString*) prefix
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (NULL == node) if (NULL == theNode)
{ {
return nil; return nil;
} }
if (XML_NAMESPACE_DECL == node->type) if (XML_NAMESPACE_DECL == theNode->type)
{ {
return @""; return @"";
} }
if (XML_ELEMENT_NODE != node->type) if (XML_ELEMENT_NODE != theNode->type)
{ {
return @""; return @"";
} }
if (node->ns == NULL) if (theNode->ns == NULL)
{ {
return @""; return @"";
} }
return StringFromXMLStringPtr(node->ns->prefix); return StringFromXMLStringPtr(theNode->ns->prefix);
} }
- (NSXMLNode*) previousNode - (NSXMLNode*) previousNode
@ -1670,32 +1670,32 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
- (NSXMLNode*) previousSibling - (NSXMLNode*) previousSibling
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (NULL == node) if (NULL == theNode)
{ {
return nil; return nil;
} }
if (XML_NAMESPACE_DECL == node->type) if (XML_NAMESPACE_DECL == theNode->type)
{ {
return nil; return nil;
} }
return [NSXMLNode _objectForNode: node->prev]; return [NSXMLNode _objectForNode: theNode->prev];
} }
- (NSXMLDocument*) rootDocument - (NSXMLDocument*) rootDocument
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (NULL == node) if (NULL == theNode)
{ {
return nil; return nil;
} }
if (XML_NAMESPACE_DECL == node->type) if (XML_NAMESPACE_DECL == theNode->type)
{ {
return nil; return nil;
} }
if ((NULL == node->doc) || (NULL == node->doc->children)) if ((NULL == theNode->doc) || (NULL == theNode->doc->children))
{ {
// This is a standalone node, we still may have a private document, // This is a standalone node, we still may have a private document,
// but we don't want to return this. // but we don't want to return this.
@ -1703,13 +1703,13 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
} }
return return
(NSXMLDocument *)[NSXMLNode _objectForNode: (xmlNodePtr)(node->doc)]; (NSXMLDocument *)[NSXMLNode _objectForNode: (xmlNodePtr)(theNode->doc)];
} }
- (NSString*) stringValue - (NSString*) stringValue
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
xmlChar *content = xmlNodeGetContent(node); xmlChar *content = xmlNodeGetContent(theNode);
NSString *result = nil; NSString *result = nil;
if (NULL != content) if (NULL != content)
@ -1738,16 +1738,16 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
- (void) setName: (NSString *)name - (void) setName: (NSString *)name
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (NSXMLInvalidKind == internal->kind) if (NSXMLInvalidKind == internal->kind)
{ {
return; return;
} }
if (node->type == XML_NAMESPACE_DECL) if (theNode->type == XML_NAMESPACE_DECL)
{ {
xmlNsPtr ns = (xmlNsPtr)node; xmlNsPtr ns = (xmlNsPtr)theNode;
if (ns->prefix != NULL) if (ns->prefix != NULL)
{ {
@ -1763,40 +1763,40 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
if (NULL == xmlName) if (NULL == xmlName)
{ {
xmlNodeSetName(node, (const xmlChar *)""); xmlNodeSetName(theNode, (const xmlChar *)"");
return; return;
} }
localName = xmlSplitQName2(xmlName, &prefix); localName = xmlSplitQName2(xmlName, &prefix);
if (prefix != NULL) if (prefix != NULL)
{ {
if ((node->type == XML_ATTRIBUTE_NODE) || if ((theNode->type == XML_ATTRIBUTE_NODE) ||
(node->type == XML_ELEMENT_NODE)) (theNode->type == XML_ELEMENT_NODE))
{ {
if ((node->ns != NULL && node->ns->prefix == NULL)) if ((theNode->ns != NULL && theNode->ns->prefix == NULL))
{ {
node->ns->prefix = xmlStrdup(prefix); theNode->ns->prefix = xmlStrdup(prefix);
} }
else else
{ {
xmlNsPtr ns; xmlNsPtr ns;
// Set namespace // Set namespace
ns = xmlSearchNs(node->doc, node, prefix); ns = xmlSearchNs(theNode->doc, theNode, prefix);
if (ns) if (ns)
{ {
xmlSetNs(node, ns); xmlSetNs(theNode, ns);
} }
else else
{ {
xmlNsPtr oldNs; xmlNsPtr oldNs;
ensure_oldNs(node); ensure_oldNs(theNode);
// Fake the name space and fix it later // Fake the name space and fix it later
// This function is private, so re reimplemt it. // This function is private, so re reimplemt it.
//ns = xmlDOMWrapStoreNs(node->doc, NULL, prefix); //ns = xmlDOMWrapStoreNs(node->doc, NULL, prefix);
oldNs = node->doc->oldNs; oldNs = theNode->doc->oldNs;
while (oldNs) while (oldNs)
{ {
if (oldNs->prefix != NULL && xmlStrEqual(oldNs->prefix, prefix)) if (oldNs->prefix != NULL && xmlStrEqual(oldNs->prefix, prefix))
@ -1812,18 +1812,18 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
} }
oldNs = oldNs->next; oldNs = oldNs->next;
} }
xmlSetNs(node, ns); xmlSetNs(theNode, ns);
} }
} }
} }
xmlNodeSetName(node, localName); xmlNodeSetName(theNode, localName);
xmlFree(localName); xmlFree(localName);
xmlFree(prefix); xmlFree(prefix);
} }
else else
{ {
xmlNodeSetName(node, xmlName); xmlNodeSetName(theNode, xmlName);
} }
} }
} }
@ -1835,11 +1835,11 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
- (void) setStringValue: (NSString*)string resolvingEntities: (BOOL)resolve - (void) setStringValue: (NSString*)string resolvingEntities: (BOOL)resolve
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (node->type == XML_NAMESPACE_DECL) if (theNode->type == XML_NAMESPACE_DECL)
{ {
xmlNsPtr ns = (xmlNsPtr)node; xmlNsPtr ns = (xmlNsPtr)theNode;
if (ns->href != NULL) if (ns->href != NULL)
{ {
xmlFree((xmlChar *)ns->href); xmlFree((xmlChar *)ns->href);
@ -1851,8 +1851,8 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
// Remove all child nodes except attributes // Remove all child nodes except attributes
if (internal->subNodes) if (internal->subNodes)
{ {
NSArray *subNodes = [internal->subNodes copy]; NSArray *theSubNodes = [internal->subNodes copy];
NSEnumerator *enumerator = [subNodes objectEnumerator]; NSEnumerator *enumerator = [theSubNodes objectEnumerator];
NSXMLNode *subNode; NSXMLNode *subNode;
while ((subNode = [enumerator nextObject]) != nil) while ((subNode = [enumerator nextObject]) != nil)
@ -1862,18 +1862,19 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
[subNode detach]; [subNode detach];
} }
} }
[theSubNodes release];
} }
if (resolve == NO) if (resolve == NO)
{ {
xmlNodeSetContent(node, XMLSTRING(string)); xmlNodeSetContent(theNode, XMLSTRING(string));
} }
else else
{ {
// need to actually resolve entities... // need to actually resolve entities...
// is this the right functionality?? xmlEncodeSpecialChars() // is this the right functionality?? xmlEncodeSpecialChars()
xmlChar *newstr = xmlEncodeEntitiesReentrant(node->doc, XMLSTRING(string)); xmlChar *newstr = xmlEncodeEntitiesReentrant(theNode->doc, XMLSTRING(string));
xmlNodeSetContent(node, newstr); xmlNodeSetContent(theNode, newstr);
xmlMemFree(newstr); xmlMemFree(newstr);
} }
} }
@ -1882,49 +1883,49 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
- (void) setURI: (NSString*)URI - (void) setURI: (NSString*)URI
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (NSXMLInvalidKind == internal->kind) if (NSXMLInvalidKind == internal->kind)
{ {
return; return;
} }
if ((node->type == XML_ATTRIBUTE_NODE) || if ((theNode->type == XML_ATTRIBUTE_NODE) ||
(node->type == XML_ELEMENT_NODE)) (theNode->type == XML_ELEMENT_NODE))
{ {
const xmlChar *uri = XMLSTRING(URI); const xmlChar *uri = XMLSTRING(URI);
xmlNsPtr ns; xmlNsPtr ns;
if (uri == NULL) if (uri == NULL)
{ {
node->ns = NULL; theNode->ns = NULL;
return; return;
} }
ns = xmlSearchNsByHref(node->doc, node, uri); ns = xmlSearchNsByHref(theNode->doc, theNode, uri);
if (ns == NULL) if (ns == NULL)
{ {
if ((node->ns != NULL && node->ns->href == NULL)) if ((theNode->ns != NULL && theNode->ns->href == NULL))
{ {
node->ns->href = xmlStrdup(uri); theNode->ns->href = xmlStrdup(uri);
return; return;
} }
/* /*
if (node->type == XML_ELEMENT_NODE) if (theNode->type == XML_ELEMENT_NODE)
{ {
//ns = xmlNewNs(node, uri, (const xmlChar *)""); //ns = xmlNewNs(theNode, uri, (const xmlChar *)"");
ns = xmlNewNs(node, uri, NULL); ns = xmlNewNs(theNode, uri, NULL);
} }
else else
*/ */
{ {
xmlNsPtr oldNs; xmlNsPtr oldNs;
ensure_oldNs(node); ensure_oldNs(theNode);
// Fake the name space and fix it later // Fake the name space and fix it later
// This function is private, so re reimplemt it. // This function is private, so re reimplemt it.
//ns = xmlDOMWrapStoreNs(node->doc, NULL, prefix); //ns = xmlDOMWrapStoreNs(node->doc, NULL, prefix);
oldNs = node->doc->oldNs; oldNs = theNode->doc->oldNs;
while (oldNs) while (oldNs)
{ {
if (oldNs->href != NULL && xmlStrEqual(oldNs->href, uri)) if (oldNs->href != NULL && xmlStrEqual(oldNs->href, uri))
@ -1943,22 +1944,22 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
} }
} }
xmlSetNs(node, ns); xmlSetNs(theNode, ns);
} }
} }
- (NSString*) URI - (NSString*) URI
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (NSXMLInvalidKind == internal->kind) if (NSXMLInvalidKind == internal->kind)
{ {
return nil; return nil;
} }
if ((node->type == XML_ATTRIBUTE_NODE) || if ((theNode->type == XML_ATTRIBUTE_NODE) ||
(node->type == XML_ELEMENT_NODE)) (theNode->type == XML_ELEMENT_NODE))
{ {
xmlNsPtr ns = internal->node->ns; xmlNsPtr ns = theNode->ns;
if ((ns != NULL) && (ns->href != NULL)) if ((ns != NULL) && (ns->href != NULL))
{ {
@ -1974,7 +1975,7 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
return [self XMLStringWithOptions: NSXMLNodeOptionsNone]; return [self XMLStringWithOptions: NSXMLNodeOptionsNone];
} }
- (NSString*) XMLStringWithOptions: (NSUInteger)options - (NSString*) XMLStringWithOptions: (NSUInteger)theOptions
{ {
NSString *string = nil; NSString *string = nil;
xmlChar *buf = NULL; xmlChar *buf = NULL;
@ -1990,20 +1991,20 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
xmlOptions |= XML_SAVE_AS_XML; xmlOptions |= XML_SAVE_AS_XML;
#endif #endif
#if LIBXML_VERSION >= 20708 #if LIBXML_VERSION >= 20708
if (options & NSXMLNodePreserveWhitespace) if (theOptions & NSXMLNodePreserveWhitespace)
{ {
xmlOptions |= XML_SAVE_WSNONSIG; xmlOptions |= XML_SAVE_WSNONSIG;
} }
#endif #endif
#if LIBXML_VERSION >= 20622 #if LIBXML_VERSION >= 20622
//NSXMLNodeExpandEmptyElement is the default //NSXMLNodeExpandEmptyElement is the default
if ((options & NSXMLNodeCompactEmptyElement) == 0) if ((theOptions & NSXMLNodeCompactEmptyElement) == 0)
{ {
xmlOptions |= XML_SAVE_NO_EMPTY; xmlOptions |= XML_SAVE_NO_EMPTY;
} }
#endif #endif
#if LIBXML_VERSION >= 20617 #if LIBXML_VERSION >= 20617
if (options & NSXMLNodePrettyPrint) if (theOptions & NSXMLNodePrettyPrint)
{ {
xmlOptions |= XML_SAVE_FORMAT; xmlOptions |= XML_SAVE_FORMAT;
} }
@ -2051,24 +2052,24 @@ execute_xpath(xmlNodePtr node, NSString *xpath_exp, NSDictionary *constants,
- (NSString*) XPath - (NSString*) XPath
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
return StringFromXMLStringPtr(xmlGetNodePath(node)); return StringFromXMLStringPtr(xmlGetNodePath(theNode));
} }
- (NSArray*) nodesForXPath: (NSString*)anxpath error: (NSError**)error - (NSArray*) nodesForXPath: (NSString*)anxpath error: (NSError**)error
{ {
xmlNodePtr node = internal->node; xmlNodePtr theNode = internal->node;
if (NSXMLInvalidKind == internal->kind) if (NSXMLInvalidKind == internal->kind)
{ {
return nil; return nil;
} }
if (node->type == XML_NAMESPACE_DECL) if (theNode->type == XML_NAMESPACE_DECL)
{ {
return nil; return nil;
} }
return execute_xpath(node, anxpath, nil, YES, error); return execute_xpath(theNode, anxpath, nil, YES, error);
} }
- (NSArray*) objectsForXQuery: (NSString*)xquery - (NSArray*) objectsForXQuery: (NSString*)xquery

6
Tests/base/NSAutoreleasePool/basic.m
View file

@ -16,9 +16,11 @@ int main()
{ {
NSAutoreleasePool *arp = [NSAutoreleasePool new]; NSAutoreleasePool *arp = [NSAutoreleasePool new];
NSObject *o = [NSObject new]; NSObject *o = [NSObject new];
for (unsigned i=0 ; i<1000 ; i++) unsigned i;
for (i = 0; i < 1000; i++)
{ {
[[o retain] autorelease]; [[o retain] autorelease];
} }
NSUInteger totalCount = [arp autoreleaseCount]; NSUInteger totalCount = [arp autoreleaseCount];
PASS(totalCount == 1000, "Autorelease count is correct"); PASS(totalCount == 1000, "Autorelease count is correct");