~ubuntu-branches/ubuntu/trusty/gnustep-base/trusty

 

#define GSInternal              NSXMLNodeInternal

#import "GSInternal.h"

GS_PRIVATE_INTERNAL(NSXMLNode)

 

  [n setName: name];

  [n setName: name];

  e = [self elementWithName: name];

  return [internal->children objectAtIndex: index];

  return internal->childCount;

- (NSArray*) children

  return internal->children;

  id c = [[self class] allocWithZone: zone];

 

  c = [c initWithKind: internal->kind options: internal->options];

  [c setName: [self name]];

  [c setURI: [self URI]];

  [c setObjectValue: [self objectValue]];

  [c setStringValue: [self stringValue]];

 

  return c;

  if (GS_EXISTS_INTERNAL)

    {

      [self detach];

      [internal->name release];

      [internal->URI release];

      [internal->children release];

      [internal->objectValue release];

      [internal->stringValue release];

      GS_DESTROY_INTERNAL(NSXMLNode);

    }

  [(NSXMLElement*)internal->parent removeChildAtIndex: [self index]];

}

 

- (NSUInteger) hash

{

  return [internal->name hash];

  if (nil == internal->parent)

    {

      return 0;

    }

  return [GSIVar(internal->parent, children) indexOfObjectIdenticalTo: self];

}

 

- (id) init

{

  return [self initWithKind: NSXMLInvalidKind];

- (id) initWithKind: (NSXMLNodeKind)kind options: (NSUInteger)theOptions

  Class theSubclass = [NSXMLNode class];

 

GSOnceMLog(@"WARNING  the XML DOM classes are not currently implemented to a usable level, but we expect to have an implementation based on libxml2 in place for the next release.");

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

    {

      return nil;

    }

 

  /*

   * We find the correct subclass for specific node kinds:

   */

  switch (kind)

    {

      case NSXMLDocumentKind:

        theSubclass = [NSXMLDocument class];

        break;

 

      case NSXMLElementKind:

        theSubclass = [NSXMLElement class];

        break;

 

      case NSXMLDTDKind:

        theSubclass = [NSXMLDTD class];

        break;

 

      case NSXMLEntityDeclarationKind:

      case NSXMLElementDeclarationKind:

      case NSXMLNotationDeclarationKind:

        theSubclass = [NSXMLDTDNode class];

        break;

 

      default:

        break;

    }

 

  /*

   * Check whether we are already initializing an instance of the given

   * subclass. If we are not, release ourselves and allocate a subclass instance

   * instead.

   */

  if (NO == [self isKindOfClass: theSubclass])

    {

      [self release];

      return [[theSubclass alloc] initWithKind: kind

                                       options: theOptions];

    }

 

  /* Create holder for internal instance variables if needed.

   */

  GS_CREATE_INTERNAL(NSXMLNode)

 

  /* If we are initializing for the correct class, we can actually perform

   * initializations:

   */

  internal->kind = kind;

  internal->options = theOptions;

  internal->stringValue = @"";

- (BOOL) isEqual: (id)other

{

  NSString      *s;

  NSArray       *c;

 

  if (other == (id)self)

    {

      return YES;

    }

 

  if (NO == [other isKindOfClass: [self class]])

    {

      return NO;

    }

 

  if ([(NSXMLNode*)other kind] != internal->kind)

    {

      return NO;

    }

 

  s = [other name];

  if (s != internal->name && NO == [s isEqual: internal->name])

    {

      return NO;

    }

 

  s = [other URI];

  if (s != internal->URI && NO == [s isEqual: internal->URI])

    {

      return NO;

    }

 

  c = [other children];

  if (c != internal->children && NO == [c isEqual: internal->children])

    {

      return NO;

    }

 

  return YES;

}

 

  return internal->kind;

  NSXMLNode     *tmp = internal->parent;

      tmp = GSIVar(tmp, parent);

  return internal->name; 

}

 

- (NSXMLNode*) _nodeFollowingInNaturalDirection: (BOOL)forward

{

  NSXMLNode *ancestor = internal->parent;

  NSXMLNode *candidate = nil;

 

  /* Node walking is a depth-first thingy. Hence, we consider children first: */

  if (0 != internal->childCount)

    {

      NSUInteger theIndex = 0;

      if (NO == forward)

        {

          theIndex = (internal->childCount) - 1;

        }

      candidate = [internal->children objectAtIndex: theIndex];

    }

 

  /* If there are no children, we move on to siblings: */

  if (nil == candidate)

    {

      if (forward)

        {

          candidate = internal->nextSibling;

        }

      else

        {

          candidate = internal->previousSibling;

        }

    }

 

  /* If there are no siblings left for the receiver, we recurse down to the root

   * of the tree until we find an ancestor with further siblings: */

  while ((nil == candidate) && (nil != ancestor))

    {

      if (forward)

        {

          candidate = [ancestor nextSibling];

        }

      else

        {

          candidate = [ancestor previousSibling];

        }

      ancestor = GSIVar(ancestor, parent);

    }

 

  /* No children, no next siblings, no next siblings for any ancestor: We are

   * the last node */

  if (nil == candidate)

    {

      return nil;

    }

 

  /* Sanity check: Namespace and attribute nodes are skipped: */

  if ((NSXMLAttributeKind == GSIVar(candidate, kind))

    || (NSXMLNamespaceKind == GSIVar(candidate, kind)))

    {

      return [candidate _nodeFollowingInNaturalDirection: forward];

    }

  return candidate;

  return [self _nodeFollowingInNaturalDirection: YES];

  return internal->nextSibling;

  return internal->objectValue;

  return internal->parent;

  return [self _nodeFollowingInNaturalDirection: NO];

  return internal->previousSibling;

 

  NSXMLNode *ancestor = internal->parent;

  /*

   * Short-circuit evaluation gurantees that the nil-pointer is not

   * dereferenced:

   */

  while ((ancestor != nil)

    && (NSXMLDocumentKind != GSIVar(ancestor, kind)))

    {

      ancestor = GSIVar(ancestor, parent);

    }

  return (NSXMLDocument*)ancestor;

  return internal->stringValue;

  return internal->URI; // FIXME ... fetch from libxml

  NSMutableString *returnValue = [NSMutableString string];

  NSXMLNodeKind kind = [self kind];

 

  if (kind == NSXMLAttributeKind)

    {

      [returnValue appendString: [self name]];

      [returnValue appendString: @"=\""];

      [returnValue appendString: [self stringValue]];

      [returnValue appendString: @"\""];

    }

  else

    {

      // for all other types, do nothing for now...

    }

 

  return returnValue;

  ASSIGN(internal->objectValue, value);

- (void) setName: (NSString *)name

  if (NSXMLInvalidKind != internal->kind)

    {

      ASSIGNCOPY(internal->name, name);

    }

  if (NSXMLInvalidKind != internal->kind)

    {

      ASSIGNCOPY(internal->URI, URI);

    }

  if (resolve == NO)

    {

      ASSIGNCOPY(internal->stringValue, string);

    }

  else

    {

      // need to actually resolve entities...

      ASSIGNCOPY(internal->stringValue, string);

    }

  if (nil == internal->stringValue)

    {

      internal->stringValue = @"";      // string value may not be nil

    }