kissdom.cc

XMDS is a code generator that integrates equations. You write them down in human readable form in a

    }
  }

  return &myElementNodeList;
};

// ******************************************************************************
Node* KissDocument::importNode(
			       const Node* importNode,
			       const bool& deep) {

  if((importNode->nodeType() == DOCUMENT_NODE) |(importNode->nodeType() == DOCUMENT_TYPE_NODE)) {
    throw DOMException(DOMException::NOT_SUPPORTED_ERR);
  }

  Node* newNode;

  if(importNode->nodeType() == ATTRIBUTE_NODE) {
    newNode = importNode->cloneNode(1);
  }
  else {
    newNode = importNode->cloneNode(deep);
  }
	
  return adoptNode(newNode);
};

// ******************************************************************************
Element* KissDocument::createElementNS(
				       const DOMString& namespaceURI,
				       const DOMString& qualifiedName) {

  if(DEBUGKISSDOM) {
    printf("KissDocument::createElementNS(); [%s]\n",nodeName()->c_str());
  }

  if(!qualifiedName.isNSWellFormed()) {
    throw DOMException(DOMException::NAMESPACE_ERR);
  }

  DOMString namePrefix;
  DOMString nameLocalPart;

  // We are definicately making a namespace element.

  if(qualifiedName.splitNSName(namePrefix,nameLocalPart)) {

    // was a namespace name

    // if the prefix is xml the namespaceURI must be exactly XML_NAMESPACEURI

    if(namePrefix.eqxml()) {
      if(namespaceURI != XML_NAMESPACEURI) {
	throw DOMException(DOMException::NAMESPACE_ERR);
      }
    }
    else if((!namePrefix.isNCName()) |namePrefix.beginsWithxml()) {
      throw DOMException(DOMException::INVALID_CHARACTER_ERR);
    }

    if((!nameLocalPart.isNCName()) |nameLocalPart.beginsWithxml()) {
      throw DOMException(DOMException::INVALID_CHARACTER_ERR);
    }
  }
  else {

    // was not a namespace name, in which case the usual xml criterior apply.

    if((!qualifiedName.isName()) |qualifiedName.beginsWithxml()) {
      throw DOMException(DOMException::INVALID_CHARACTER_ERR);
    }
  }

  return new KissElement(this,0,namespaceURI,qualifiedName);
};

// ******************************************************************************
Attr* KissDocument::createAttributeNS(
				      const DOMString& namespaceURI,
				      const DOMString& qualifiedName) {

  if(DEBUGKISSDOM) {
    printf("KissDocument::createAttributeNS(); [%s]\n",nodeName()->c_str());
  }

  if(!qualifiedName.isNSWellFormed()) {
    throw DOMException(DOMException::NAMESPACE_ERR);
  }

  DOMString namePrefix;
  DOMString nameLocalPart;

  if(qualifiedName.splitNSName(namePrefix,nameLocalPart)) {

    // was a namespace name

    // if the prefix is xml the namespaceURI must be exactly XML_NAMESPACEURI

    if(namePrefix.eqxml()) {

      // if the prefix is xml
      // the namespaceURI must be exactly XML_NAMESPACEURI

      if(namespaceURI != XML_NAMESPACEURI) {
	throw DOMException(DOMException::NAMESPACE_ERR);
      }
    }
    else if(namePrefix.eqxmlns()) {

      // or if the prefix is xmlns
      // the namespaceURI must be exactly XMLNS_NAMESPACEURI

      if(namespaceURI != XMLNS_NAMESPACEURI) {
	throw DOMException(DOMException::NAMESPACE_ERR);
      }
    }
    else if((!namePrefix.isNCName()) |namePrefix.beginsWithxml()) {
      throw DOMException(DOMException::INVALID_CHARACTER_ERR);
    }

    if((!nameLocalPart.isNCName()) |nameLocalPart.beginsWithxml()) {
      throw DOMException(DOMException::INVALID_CHARACTER_ERR);
    }
  }
  else {

    // was not a namespace name, in which case the name may be 'xmlns'
    // or any other normal xml name,

    if(!qualifiedName.eqxmlns()) {
      if((qualifiedName.isName()) |qualifiedName.beginsWithxml()) {
	throw DOMException(DOMException::INVALID_CHARACTER_ERR);
      }
    }
  }

  return new KissAttr(ownerDocument(),0,namespaceURI,qualifiedName,1);
};

// ******************************************************************************
NodeList* KissDocument::getElementsByTagNameNS(
					       const DOMString& namespaceURI,
					       const DOMString& localname) {

  if(namespaceURI.length()==0) {
    return getElementsByTagName(localname);
  }

  myElementList.clear();

  Node* nextNode = myDocumentElement;

  while (nextNode != 0) {
    if(nextNode->nodeType() == ELEMENT_NODE) {
      if(nextNode->namespaceURI() != 0) {
	if(localname == "*") {
	  myElementList.push_back(nextNode);
	}
	else if((*nextNode->namespaceURI() == namespaceURI) &(*nextNode->localName() == localname)) {
	  myElementList.push_back(nextNode);
	}
      }
    }
    if(nextNode->hasChildNodes()) {
      nextNode = nextNode->firstChild();
    }
    else {
      while((nextNode->nextSibling() == 0) &(nextNode->parentNode() != 0)) {
	nextNode = nextNode->parentNode();
      }
    }

    if(nextNode != 0) {
      nextNode = nextNode->nextSibling();
    }
  }

  return &myElementNodeList;
};

// ******************************************************************************
Element* KissDocument::getElementById(
				      const DOMString& elementId) {
  return 0;
};

// ******************************************************************************
const DOMString* KissDocument::actualEncoding() const {
  return &myActualEncoding;
};

// ******************************************************************************
void KissDocument::setActualEncoding(
				     const DOMString& newActualEncoding) {
  myActualEncoding = newActualEncoding;
};

// ******************************************************************************
const DOMString* KissDocument::encoding() const {
  return &myEncoding;
};

// ******************************************************************************
void KissDocument::setEncoding(
			       const DOMString& newEncoding) {
  myEncoding = newEncoding;
};

// ******************************************************************************
bool KissDocument::standalone() const {
  return myStandalone;
};

// ******************************************************************************
void KissDocument::setStandalone(
				 const bool& newStandalone) {
  myStandalone = newStandalone;
};

// ******************************************************************************
bool KissDocument::strictErrorChecking() const {
  return myStrictErrorChecking;
};

// ******************************************************************************
void KissDocument::setStrictErrorChecking(
					  const bool& newStrictErrorChecking) {
  myStrictErrorChecking = newStrictErrorChecking;
};

// ******************************************************************************
const DOMString* KissDocument::version() const {
  return &myVersion;
};

// ******************************************************************************
void KissDocument::setVersion(
			      const DOMString& newVersion) {
  myVersion = newVersion;
};

// ******************************************************************************
Node* KissDocument::adoptNode(
			      Node* source) {

  if(source->readOnly()) {
    throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
  }

  if(source->parentNode() != 0)	{
    if(source->parentNode()->readOnly()) {
      throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
    }
    source->parentNode()->removeChild(source);
  }

  if(source->ownerDocument() != 0) {
    if(source->ownerDocument()->implementation() != myDOMImplementation) {
      return 0;
    }
  }

  if((source->nodeType() == DOCUMENT_NODE) |(source->nodeType() == DOCUMENT_TYPE_NODE)) {
    throw DOMException(DOMException::NOT_SUPPORTED_ERR);
  }

  Node* nextNode;

  if((source->nodeType() == ATTRIBUTE_NODE)
     |(source->nodeType() == DOCUMENT_FRAGMENT_NODE)
     |(source->nodeType() == ELEMENT_NODE)
     |(source->nodeType() == ENTITY_REFERENCE_NODE)) {

    // need to check that there are no read only nodes in source's subtree

    nextNode = source->firstChild();

    while (nextNode != 0) {

      if(nextNode->readOnly()) {
	throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
      }

      if(nextNode->hasChildNodes()) {
	nextNode = nextNode->firstChild();
      }
      else {
	while((nextNode->nextSibling() == 0) &(nextNode->parentNode() != 0) &(nextNode != source)) {
	  nextNode = nextNode->parentNode();
	}
      }

      if(nextNode == source) {
	nextNode = 0;
      }

      if(nextNode != 0) {
	nextNode = nextNode->nextSibling();
      }
    }
  }

  Attr* attrNode;

  nextNode = source;

  while (nextNode != 0) {

    switch(nextNode->nodeType()) {

    case ATTRIBUTE_NODE:

      attrNode = dynamic_cast<Attr*>(nextNode);

      attrNode->setOwnerElement(0);
      attrNode->setSpecified(1);
      break;

    case ELEMENT_NODE:

      // we are supposed to remove unspecified attributes here
      // how do we do this?

      break;

    case ENTITY_REFERENCE_NODE:
      while(nextNode->hasChildNodes()) {
	delete nextNode->removeChild(source->firstChild());
      }
      break;

    case DOCUMENT_FRAGMENT_NODE:
    case PROCESSING_INSTRUCTION_NODE:
    case TEXT_NODE:
    case COMMENT_NODE:
    case CDATA_SECTION_NODE:
      break;

    default :
      return 0;
    }

    if(nextNode->hasChildNodes()) {
      nextNode = nextNode->firstChild();
    }
    else {
      while((nextNode->nextSibling() == 0) &(nextNode->parentNode() != 0) &(nextNode != source)) {
	nextNode = nextNode->parentNode();
      }
    }

    if(nextNode == source) {
      nextNode = 0;
    }

    if(nextNode != 0) {
      nextNode = nextNode->nextSibling();
    }
  }

  source->setOwnerDocument(this);

  return source;
};

// ******************************************************************************
void KissDocument::setBaseURI(
			      const DOMString *const baseURI) {
};

// ******************************************************************************
// ******************************************************************************
//	KissElement
// ******************************************************************************
// ******************************************************************************

long nKissElements=0;  //!< Number of KISS element objects

// ******************************************************************************
unsigned long KissElement::nodeType() const {
  return Node::ELEMENT_NODE;
};

// ******************************************************************************
const NamedNodeMap* KissElement::attributes() const {
  return &myAttributesMap;
};

// ******************************************************************************
void KissElement::setOwnerDocument(
				   const Document *const newOwnerDocument) {

  if(DEBUGKISSDOM) {
    printf("KissElement::setOwnerDocument() [%s]\n",nodeName()->c_str());
  }

  KissNode::setOwnerDocument(newOwnerDocument);

  myAttributesMap.setOwnerDocument(newOwnerDocument);

  for(unsigned long i = 0; i < myAttributesMap.length(); i++) {
    myAttributesMap.item(i)->setOwnerDocument(newOwnerDocument);
  }
};

// ******************************************************************************
Node* KissElement::cloneNode(
			     const bool& deep) const {

  Element* newElement = new KissElement(ownerDocument(),0,myNamespaceURI,myNodeName);

  for(unsigned long i = 0; i < myAttributesMap.length(); i++) {
    Attr* nextAttr = dynamic_cast<Attr*>(myAttributesMap.item(i));
    Attr* newAttr = dynamic_cast<Attr*>(myAttributesMap.item(i)->cloneNode(deep));
    newAttr->setSpecified(nextAttr->specified());
    newElement->setAttributeNode(*newAttr);
  }

  if(deep) {
    for(unsigned long i = 0; i < childNodes()->length(); i++) {
      newElement->appendChild(childNodes()->item(i)->cloneNode(deep));
    }
  }

  return newElement;
};

// ******************************************************************************
const DOMString* KissElement::namespaceURI() const {
  return &myNamespaceURI;
};

// ******************************************************************************
const DOMString* KissElement::prefix() const {
  return &myPrefix;
};

// ******************************************************************************
void KissElement::setPrefix(
			    const DOMString& newPrefix) {

  // if I am not a namespace element do nothing

  if(myNamespaceURI.length()==0) {
    return;
  }

  if(myReadOnly) {
    throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
  }

  if(newPrefix == 0) {
    throw DOMException(DOMException::NAMESPACE_ERR);
  }

  if(!newPrefix.isNCName()) {
    throw DOMException(DOMException::INVALID_CHARACTER_ERR);
  }
	
  if(newPrefix.eqxml() &(myNamespaceURI != XML_NAMESPACEURI)) {
    throw DOMException(DOMException::NAMESPACE_ERR);
  }

  myPrefix = newPrefix;
  if(myPrefix.length() != 0) {
    myNodeName = myPrefix;
    myNodeName += ":";
    myNodeName += myLocalname;
  }
  else
    myNodeName = myLocalname;
};

// ******************************************************************************
const DOMString* KissElement::localName() const {
  return &myLocalname;
};

// ******************************************************************************
bool KissElement::hasAttributes() const {
  return (myAttributesMap.length() != 0);
};

// ******************************************************************************
void KissElement::normalizeNS() {

  enum {
    ACTION_ARBITRARY_PREFIX = 1,
    ACTION_CHANGE_PREFIX = 2,
    ACTION_NEW_BINDIN