void XSDDOMParser::endAnnotationElement( const XMLElementDecl& elemDecl , bool complete) { if (complete) { fAnnotationBuf.append(chLF); fAnnotationBuf.append(chOpenAngle); fAnnotationBuf.append(chForwardSlash); fAnnotationBuf.append(elemDecl.getFullName()); fAnnotationBuf.append(chCloseAngle); // note that this is always called after endElement on <annotation>'s // child and before endElement on annotation. // hence, we must make this the child of the current // parent's only child. DOMTextImpl *node = (DOMTextImpl *)fDocument->createTextNode(fAnnotationBuf.getRawBuffer()); fCurrentNode->appendChild(node); fAnnotationBuf.reset(); } else //capturing character calls { fAnnotationBuf.append(chOpenAngle); fAnnotationBuf.append(chForwardSlash); fAnnotationBuf.append(elemDecl.getFullName()); fAnnotationBuf.append(chCloseAngle); } }
void SAXParser::endElement( const XMLElementDecl& elemDecl , const unsigned int uriId , const bool isRoot , const XMLCh* const elemPrefix) { // Just map to the SAX document handler if (fDocHandler) { if (fScanner->getDoNamespaces()) { if (elemPrefix && *elemPrefix) { fElemQNameBuf.set(elemPrefix); fElemQNameBuf.append(chColon); fElemQNameBuf.append(elemDecl.getBaseName()); fDocHandler->endElement(fElemQNameBuf.getRawBuffer()); } else { fDocHandler->endElement(elemDecl.getBaseName()); } } else fDocHandler->endElement(elemDecl.getFullName()); } // // If there are any installed advanced handlers, then lets call them // with this info. // for (XMLSize_t index = 0; index < fAdvDHCount; index++) fAdvDHList[index]->endElement(elemDecl, uriId, isRoot, elemPrefix); // // Dump the element depth down again. Don't let it underflow in case // of malformed XML. // if (fElemDepth) fElemDepth--; }
void TestParser::endElement(const XMLElementDecl& elemDecl , const unsigned int uriId , const bool isRoot) { if (fOutputType == OutputType_Debug) { if (fDoNamespaces) { XMLBuffer bufURI; fScanner->getURIText(uriId, bufURI); XERCES_STD_QUALIFIER cout << "Got ENDELEMENT:\n Name: " << "{" << StrX(bufURI.getRawBuffer()) << "}" << StrX(elemDecl.getBaseName()) << XERCES_STD_QUALIFIER endl; } else { XERCES_STD_QUALIFIER cout << "Got ENDELEMENT:\n Name: " << StrX(elemDecl.getFullName()) << XERCES_STD_QUALIFIER endl; } XERCES_STD_QUALIFIER cout << " SrcOfs: " << fScanner->getSrcOffset() << "\n" << XERCES_STD_QUALIFIER endl; } else if ((fOutputType == OutputType_XML) || (fOutputType == OutputType_JCCanon) || (fOutputType == OutputType_SunCanon)) { XERCES_STD_QUALIFIER cout << "</"; showString(elemDecl.getFullName()); XERCES_STD_QUALIFIER cout << ">"; } // Clear the flag that says we're now inside the root if (isRoot) fInsideRoot = false; }
void NsSAX2Reader::endElement(const XMLElementDecl& elemDecl, const unsigned int uriId, const_bool isRoot, const XMLCh* const elemPrefix) { const XMLCh *uri = 0; if (uriId >= DBXML_MIN_URI && getDoNamespaces()) uri = getURIText(uriId); fHandler->endElement(elemDecl.getBaseName(), (elemPrefix && *elemPrefix) ? elemPrefix : 0, uri); // // Dump the element depth down again. Don't let it underflow in case // of malformed XML. // if (fElemDepth) fElemDepth--; }
void XSDDOMParser::startAnnotationElement( const XMLElementDecl& elemDecl , const RefVectorOf<XMLAttr>& attrList , const unsigned int attrCount) { fAnnotationBuf.append(chOpenAngle); fAnnotationBuf.append(elemDecl.getFullName()); //fAnnotationBuf.append(chSpace); for(unsigned int i=0; i < attrCount; i++) { const XMLAttr* oneAttr = attrList.elementAt(i); fAnnotationBuf.append(chSpace); fAnnotationBuf.append(oneAttr ->getQName()); fAnnotationBuf.append(chEqual); fAnnotationBuf.append(chDoubleQuote); fAnnotationBuf.append(oneAttr->getValue()); fAnnotationBuf.append(chDoubleQuote); } fAnnotationBuf.append(chCloseAngle); }
void NsSAX2Reader::startElement( const XMLElementDecl& elemDecl, const unsigned int elemURLId, const XMLCh* const elemPrefix, const RefVectorOf<XMLAttr>& attrList, const XercesSizeUint attrCount, const_bool isEmpty, const_bool isRoot) { NsEventAttrListXimpl alist(attrList, *this, (unsigned int)attrCount); const XMLCh *uri = 0; unsigned int uriId = elemURLId; if (uriId >= DBXML_MIN_URI && getDoNamespaces()) uri = getURIText(elemURLId); fHandler->startElement(elemDecl.getBaseName(), (elemPrefix && *elemPrefix) ? elemPrefix : 0, uri, &alist, (unsigned int)attrCount, isEmpty); // Bump the element depth counter if not empty if (!isEmpty) fElemDepth++; }
void SAXParser:: startElement( const XMLElementDecl& elemDecl , const unsigned int elemURLId , const XMLCh* const elemPrefix , const RefVectorOf<XMLAttr>& attrList , const XMLSize_t attrCount , const bool isEmpty , const bool isRoot) { // Bump the element depth counter if not empty if (!isEmpty) fElemDepth++; if (fDocHandler) { fAttrList.setVector(&attrList, attrCount); if (fScanner->getDoNamespaces()) { if (elemPrefix && *elemPrefix) { fElemQNameBuf.set(elemPrefix); fElemQNameBuf.append(chColon); fElemQNameBuf.append(elemDecl.getBaseName()); fDocHandler->startElement(fElemQNameBuf.getRawBuffer(), fAttrList); // If its empty, send the end tag event now if (isEmpty && fDocHandler) fDocHandler->endElement(fElemQNameBuf.getRawBuffer()); } else { fDocHandler->startElement(elemDecl.getBaseName(), fAttrList); // If its empty, send the end tag event now if (isEmpty && fDocHandler) fDocHandler->endElement(elemDecl.getBaseName()); } } else { fDocHandler->startElement(elemDecl.getFullName(), fAttrList); // If its empty, send the end tag event now if (isEmpty && fDocHandler) fDocHandler->endElement(elemDecl.getFullName()); } } // // If there are any installed advanced handlers, then lets call them // with this info. // for (XMLSize_t index = 0; index < fAdvDHCount; index++) { fAdvDHList[index]->startElement ( elemDecl , elemURLId , elemPrefix , attrList , attrCount , isEmpty , isRoot ); } }
bool XSAXMLScanner::scanStartTag(bool& gotData) { // Assume we will still have data until proven otherwise. It will only // ever be false if this is the root and its empty. gotData = true; // Reset element content fContent.reset(); // The current position is after the open bracket, so we need to read in // in the element name. int prefixColonPos; if (!fReaderMgr.getQName(fQNameBuf, &prefixColonPos)) { if (fQNameBuf.isEmpty()) emitError(XMLErrs::ExpectedElementName); else emitError(XMLErrs::InvalidElementName, fQNameBuf.getRawBuffer()); fReaderMgr.skipToChar(chOpenAngle); return false; } // See if its the root element const bool isRoot = fElemStack.isEmpty(); // Skip any whitespace after the name fReaderMgr.skipPastSpaces(); // First we have to do the rawest attribute scan. We don't do any // normalization of them at all, since we don't know yet what type they // might be (since we need the element decl in order to do that.) const XMLCh* qnameRawBuf = fQNameBuf.getRawBuffer(); bool isEmpty; unsigned int attCount = rawAttrScan(qnameRawBuf, *fRawAttrList, isEmpty); // save the contentleafname and currentscope before addlevel, for later use ContentLeafNameTypeVector* cv = 0; XMLContentModel* cm = 0; int currentScope = Grammar::TOP_LEVEL_SCOPE; bool laxThisOne = false; if (!isRoot) { // schema validator will have correct type if validating SchemaElementDecl* tempElement = (SchemaElementDecl*) fElemStack.topElement()->fThisElement; SchemaElementDecl::ModelTypes modelType = tempElement->getModelType(); ComplexTypeInfo *currType = 0; if (fValidate) { currType = ((SchemaValidator*)fValidator)->getCurrentTypeInfo(); if (currType) modelType = (SchemaElementDecl::ModelTypes)currType->getContentType(); else // something must have gone wrong modelType = SchemaElementDecl::Any; } else { currType = tempElement->getComplexTypeInfo(); } if ((modelType == SchemaElementDecl::Mixed_Simple) || (modelType == SchemaElementDecl::Mixed_Complex) || (modelType == SchemaElementDecl::Children)) { cm = currType->getContentModel(); cv = cm->getContentLeafNameTypeVector(); currentScope = fElemStack.getCurrentScope(); } else if (modelType == SchemaElementDecl::Any) { laxThisOne = true; } } // Now, since we might have to update the namespace map for this element, // but we don't have the element decl yet, we just tell the element stack // to expand up to get ready. unsigned int elemDepth = fElemStack.addLevel(); fElemStack.setValidationFlag(fValidate); fElemStack.setPrefixColonPos(prefixColonPos); // Make an initial pass through the list and find any xmlns attributes or // schema attributes. if (attCount) scanRawAttrListforNameSpaces(attCount); // Resolve the qualified name to a URI and name so that we can look up // the element decl for this element. We have now update the prefix to // namespace map so we should get the correct element now. unsigned int uriId = resolveQNameWithColon ( qnameRawBuf, fPrefixBuf, ElemStack::Mode_Element, prefixColonPos ); //if schema, check if we should lax or skip the validation of this element bool parentValidation = fValidate; if (cv) { QName element(fPrefixBuf.getRawBuffer(), &qnameRawBuf[prefixColonPos + 1], uriId, fMemoryManager); // elementDepth will be > 0, as cv is only constructed if element is not // root. laxThisOne = laxElementValidation(&element, cv, cm, elemDepth - 1); } // Look up the element now in the grammar. This will get us back a // generic element decl object. We tell him to fault one in if he does // not find it. bool wasAdded = false; const XMLCh* nameRawBuf = &qnameRawBuf[prefixColonPos + 1]; XMLElementDecl* elemDecl = fGrammar->getElemDecl ( uriId, nameRawBuf, qnameRawBuf, currentScope ); if (!elemDecl) { // URI is different, so we try to switch grammar if (uriId != fURIStringPool->getId(fGrammar->getTargetNamespace())) { switchGrammar(getURIText(uriId), laxThisOne); } // look for a global element declaration elemDecl = fGrammar->getElemDecl( uriId, nameRawBuf, qnameRawBuf, Grammar::TOP_LEVEL_SCOPE ); if (!elemDecl) { // if still not found, look in list of undeclared elements elemDecl = fElemNonDeclPool->getByKey( nameRawBuf, uriId, Grammar::TOP_LEVEL_SCOPE); if (!elemDecl) { elemDecl = new (fMemoryManager) SchemaElementDecl ( fPrefixBuf.getRawBuffer(), nameRawBuf, uriId , SchemaElementDecl::Any, Grammar::TOP_LEVEL_SCOPE , fMemoryManager ); elemDecl->setId ( fElemNonDeclPool->put ( (void*)elemDecl->getBaseName(), uriId , Grammar::TOP_LEVEL_SCOPE, (SchemaElementDecl*)elemDecl ) ); wasAdded = true; } } } // We do something different here according to whether we found the // element or not. if (wasAdded || !elemDecl->isDeclared()) { if (laxThisOne) { fValidate = false; fElemStack.setValidationFlag(fValidate); } // If validating then emit an error if (fValidate) { // This is to tell the reuse Validator that this element was // faulted-in, was not an element in the grammar pool originally elemDecl->setCreateReason(XMLElementDecl::JustFaultIn); fValidator->emitError ( XMLValid::ElementNotDefined, elemDecl->getFullName() ); } } // Now we can update the element stack to set the current element // decl. We expanded the stack above, but couldn't store the element // decl because we didn't know it yet. fElemStack.setElement(elemDecl, fReaderMgr.getCurrentReaderNum()); fElemStack.setCurrentURI(uriId); if (isRoot) { fRootElemName = XMLString::replicate(qnameRawBuf, fMemoryManager); } // Validate the element if (fValidate) { fValidator->validateElement(elemDecl); } // squirrel away the element's QName, so that we can do an efficient // end-tag match fElemStack.setCurrentSchemaElemName(fQNameBuf.getRawBuffer()); ComplexTypeInfo* typeinfo = (fValidate) ? ((SchemaValidator*)fValidator)->getCurrentTypeInfo() : ((SchemaElementDecl*) elemDecl)->getComplexTypeInfo(); if (typeinfo) { currentScope = typeinfo->getScopeDefined(); // switch grammar if the typeinfo has a different grammar XMLCh* typeName = typeinfo->getTypeName(); int comma = XMLString::indexOf(typeName, chComma); if (comma > 0) { XMLBufBid bbPrefix(&fBufMgr); XMLBuffer& prefixBuf = bbPrefix.getBuffer(); prefixBuf.append(typeName, comma); switchGrammar(prefixBuf.getRawBuffer(), laxThisOne); } } fElemStack.setCurrentScope(currentScope); // Set element next state if (elemDepth >= fElemStateSize) { resizeElemState(); } fElemState[elemDepth] = 0; fElemStack.setCurrentGrammar(fGrammar); // If this is the first element and we are validating, check the root // element. if (!isRoot && parentValidation) { fElemStack.addChild(elemDecl->getElementName(), true); } // Now lets get the fAttrList filled in. This involves faulting in any // defaulted and fixed attributes and normalizing the values of any that // we got explicitly. // // We update the attCount value with the total number of attributes, but // it goes in with the number of values we got during the raw scan of // explictly provided attrs above. attCount = buildAttList(*fRawAttrList, attCount, elemDecl, *fAttrList); if(attCount) { // clean up after ourselves: // clear the map used to detect duplicate attributes fUndeclaredAttrRegistryNS->removeAll(); } // Since the element may have default values, call start tag now regardless if it is empty or not // If we have a document handler, then tell it about this start tag if (fDocHandler) { fDocHandler->startElement ( *elemDecl, uriId, fPrefixBuf.getRawBuffer(), *fAttrList , attCount, false, isRoot ); } // may be where we output something... // If empty, validate content right now if we are validating and then // pop the element stack top. Else, we have to update the current stack // top's namespace mapping elements. if (isEmpty) { // Pop the element stack back off since it'll never be used now fElemStack.popTop(); // If validating, then insure that its legal to have no content if (fValidate) { const int res = fValidator->checkContent(elemDecl, 0, 0); if (res >= 0) { // REVISIT: in the case of xsi:type, this may // return the wrong string... fValidator->emitError ( XMLValid::ElementNotValidForContent , elemDecl->getFullName() , elemDecl->getFormattedContentModel() ); } } // If we have a doc handler, tell it about the end tag if (fDocHandler) { fDocHandler->endElement ( *elemDecl, uriId, isRoot, fPrefixBuf.getRawBuffer() ); } // If the elem stack is empty, then it was an empty root if (isRoot) { gotData = false; } else { // Restore the grammar fGrammar = fElemStack.getCurrentGrammar(); fGrammarType = fGrammar->getGrammarType(); fValidator->setGrammar(fGrammar); // Restore the validation flag fValidate = fElemStack.getValidationFlag(); } } return true; }
void XSDDOMParser::startAnnotation( const XMLElementDecl& elemDecl , const RefVectorOf<XMLAttr>& attrList , const unsigned int attrCount) { fAnnotationBuf.append(chOpenAngle); fAnnotationBuf.append(elemDecl.getFullName()); fAnnotationBuf.append(chSpace); // attributes are a bit of a pain. To get this right, we have to keep track // of the namespaces we've seen declared, then examine the namespace context // for other namespaces so that we can also include them. // optimized for simplicity and the case that not many // namespaces are declared on this annotation... fURIs->removeAllElements(); for (unsigned int i=0; i < attrCount; i++) { const XMLAttr* oneAttrib = attrList.elementAt(i); const XMLCh* attrValue = oneAttrib->getValue(); if (XMLString::equals(oneAttrib->getName(), XMLUni::fgXMLNSString)) fURIs->addElement(fScanner->getPrefixId(XMLUni::fgZeroLenString)); else if (!XMLString::compareNString(oneAttrib->getQName(), XMLUni::fgXMLNSColonString, 6)) fURIs->addElement(fScanner->getPrefixId(oneAttrib->getName())); fAnnotationBuf.append(oneAttrib->getQName()); fAnnotationBuf.append(chEqual); fAnnotationBuf.append(chDoubleQuote); fAnnotationBuf.append(attrValue); fAnnotationBuf.append(chDoubleQuote); fAnnotationBuf.append(chSpace); } // now we have to look through currently in-scope namespaces to see what // wasn't declared here ValueVectorOf<PrefMapElem*>* namespaceContext = fScanner->getNamespaceContext(); for (unsigned int j=0; j < namespaceContext->size(); j++) { unsigned int prefId = namespaceContext->elementAt(j)->fPrefId; if (!fURIs->containsElement(prefId)) { const XMLCh* prefix = fScanner->getPrefixForId(prefId); if (XMLString::equals(prefix, XMLUni::fgZeroLenString)) { fAnnotationBuf.append(XMLUni::fgXMLNSString); } else { fAnnotationBuf.append(XMLUni::fgXMLNSColonString); fAnnotationBuf.append(prefix); } fAnnotationBuf.append(chEqual); fAnnotationBuf.append(chDoubleQuote); fAnnotationBuf.append(fScanner->getURIText(namespaceContext->elementAt(j)->fURIId)); fAnnotationBuf.append(chDoubleQuote); fAnnotationBuf.append(chSpace); } } fAnnotationBuf.append(chCloseAngle); fAnnotationBuf.append(chLF); }
// --------------------------------------------------------------------------- // XSDDOMParser: Implementation of the XMLDocumentHandler interface // --------------------------------------------------------------------------- void XSDDOMParser::startElement( const XMLElementDecl& elemDecl , const unsigned int urlId , const XMLCh* const elemPrefix , const RefVectorOf<XMLAttr>& attrList , const unsigned int attrCount , const bool isEmpty , const bool isRoot) { fDepth++; // while it is true that non-whitespace character data // may only occur in appInfo or documentation // elements, it's certainly legal for comments and PI's to // occur as children of annotation; we need // to account for these here. if (fAnnotationDepth == -1) { if (XMLString::equals(elemDecl.getBaseName(), SchemaSymbols::fgELT_ANNOTATION) && XMLString::equals(getURIText(urlId), SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) { fAnnotationDepth = fDepth; startAnnotation(elemDecl, attrList, attrCount); } } else if (fDepth == fAnnotationDepth+1) { fInnerAnnotationDepth = fDepth; startAnnotationElement(elemDecl, attrList, attrCount); } else { startAnnotationElement(elemDecl, attrList, attrCount); // avoid falling through; don't call startElement in this case return; } DOMElement *elem; if (urlId != fScanner->getEmptyNamespaceId()) //TagName has a prefix { if (elemPrefix && *elemPrefix) { XMLBufBid elemQName(&fBufMgr); elemQName.set(elemPrefix); elemQName.append(chColon); elemQName.append(elemDecl.getBaseName()); elem = createElementNSNode( fScanner->getURIText(urlId), elemQName.getRawBuffer()); } else { elem = createElementNSNode( fScanner->getURIText(urlId), elemDecl.getBaseName()); } } else { elem = createElementNSNode(0, elemDecl.getBaseName()); } DOMElementImpl *elemImpl = (DOMElementImpl *) elem; for (unsigned int index = 0; index < attrCount; ++index) { const XMLAttr* oneAttrib = attrList.elementAt(index); unsigned int attrURIId = oneAttrib->getURIId(); const XMLCh* namespaceURI = 0; //for xmlns=... if (XMLString::equals(oneAttrib->getName(), XMLUni::fgXMLNSString)) attrURIId = fScanner->getXMLNSNamespaceId(); //TagName has a prefix if (attrURIId != fScanner->getEmptyNamespaceId()) namespaceURI = fScanner->getURIText(attrURIId); //get namespaceURI // revisit. Optimize to init the named node map to the // right size up front. DOMAttrImpl *attr = (DOMAttrImpl *) fDocument->createAttributeNS(namespaceURI, oneAttrib->getQName()); attr->setValue(oneAttrib -> getValue()); DOMNode* remAttr = elemImpl->setAttributeNodeNS(attr); if (remAttr) remAttr->release(); // Attributes of type ID. If this is one, add it to the hashtable of IDs // that is constructed for use by GetElementByID(). if (oneAttrib->getType()==XMLAttDef::ID) { if (fDocument->fNodeIDMap == 0) fDocument->fNodeIDMap = new (fDocument) DOMNodeIDMap(500, fDocument); fDocument->fNodeIDMap->add(attr); attr->fNode.isIdAttr(true); } attr->setSpecified(oneAttrib->getSpecified()); } // set up the default attributes if (elemDecl.hasAttDefs()) { XMLAttDefList* defAttrs = &elemDecl.getAttDefList(); XMLAttDef* attr = 0; DOMAttrImpl * insertAttr = 0; while (defAttrs->hasMoreElements()) { attr = &defAttrs->nextElement(); const XMLAttDef::DefAttTypes defType = attr->getDefaultType(); if ((defType == XMLAttDef::Default) || (defType == XMLAttDef::Fixed)) { // DOM Level 2 wants all namespace declaration attributes // to be bound to "http://www.w3.org/2000/xmlns/" // So as long as the XML parser doesn't do it, it needs to // done here. const XMLCh* qualifiedName = attr->getFullName(); XMLBufBid bbPrefixQName(&fBufMgr); XMLBuffer& prefixBuf = bbPrefixQName.getBuffer(); int colonPos = -1; unsigned int uriId = fScanner->resolveQName(qualifiedName, prefixBuf, ElemStack::Mode_Attribute, colonPos); const XMLCh* namespaceURI = 0; if (XMLString::equals(qualifiedName, XMLUni::fgXMLNSString)) uriId = fScanner->getXMLNSNamespaceId(); //TagName has a prefix if (uriId != fScanner->getEmptyNamespaceId()) namespaceURI = fScanner->getURIText(uriId); insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS( namespaceURI, qualifiedName); DOMAttr* remAttr = elemImpl->setDefaultAttributeNodeNS(insertAttr); if (remAttr) remAttr->release(); if (attr->getValue() != 0) { insertAttr->setValue(attr->getValue()); insertAttr->setSpecified(false); } } insertAttr = 0; attr->reset(); } } fCurrentParent->appendChild(elem); fNodeStack->push(fCurrentParent); fCurrentParent = elem; fCurrentNode = elem; fWithinElement = true; // If an empty element, do end right now (no endElement() will be called) if (isEmpty) endElement(elemDecl, urlId, isRoot, elemPrefix); }
void TestParser::startElement(const XMLElementDecl& elemDecl , const unsigned int uriId , const XMLCh* const prefixName , const RefVectorOf<XMLAttr>& attrList , const unsigned int attCount , const bool isEmpty , const bool isRoot) { // Set the flag that says we're now inside the root, if its not empty if (isRoot && !isEmpty) fInsideRoot = true; if (fOutputType == OutputType_Debug) { XMLBuffer bufURI; if (fDoNamespaces) { fScanner->getURIText(uriId, bufURI); XERCES_STD_QUALIFIER cout << "Got STARTELEMENT:\n " << " Name: {" << StrX(bufURI.getRawBuffer()) << "}" << StrX(elemDecl.getBaseName()) << ", AttCount: " << attCount << ", Empty?: " << (isEmpty ? "yes" : "no") << "\n"; } else { XERCES_STD_QUALIFIER cout << "Got STARTELEMENT:\n Name: " << StrX(elemDecl.getFullName()) << ", AttCount: " << attCount << ", Empty?: " << (isEmpty ? "yes" : "no") << "\n"; } XERCES_STD_QUALIFIER cout << " SrcOfs: " << fScanner->getSrcOffset() << "\n"; // If any attributes, then show them if (attCount) { XERCES_STD_QUALIFIER cout << " Attrs: "; for (unsigned int attInd = 0; attInd < attCount; attInd++) { const XMLAttr* curAttr = attrList.elementAt(attInd); if (fDoNamespaces) { fScanner->getURIText(curAttr->getURIId(), bufURI); XERCES_STD_QUALIFIER cout << "Name=" << "{" << StrX(bufURI.getRawBuffer()) << "}" << StrX(curAttr->getName()); } else { XERCES_STD_QUALIFIER cout << "Name=" << StrX(curAttr->getQName()); } if (curAttr->getSpecified()) XERCES_STD_QUALIFIER cout << " (Explicit) "; else XERCES_STD_QUALIFIER cout << " (Defaulted) "; XERCES_STD_QUALIFIER cout << "Value=" << StrX(curAttr->getValue()) << "\n" << " "; } } XERCES_STD_QUALIFIER cout << XERCES_STD_QUALIFIER endl; } else if (fOutputType == OutputType_XML) { XERCES_STD_QUALIFIER cout << "<"; showString(elemDecl.getFullName()); if (attCount) { XERCES_STD_QUALIFIER cout << " "; for (unsigned int index = 0; index < attCount; index++) { const XMLAttr* curAttr = attrList.elementAt(index); showString(curAttr->getQName()); XERCES_STD_QUALIFIER cout << "=\""; showString(curAttr->getValue()); XERCES_STD_QUALIFIER cout << "\""; if (index < attCount-1) XERCES_STD_QUALIFIER cout << " "; } } if (isEmpty) XERCES_STD_QUALIFIER cout << "/>"; else XERCES_STD_QUALIFIER cout << ">"; } else if ((fOutputType == OutputType_JCCanon) || (fOutputType == OutputType_SunCanon)) { XERCES_STD_QUALIFIER cout << "<"; showString(elemDecl.getFullName()); if (attCount) { XERCES_STD_QUALIFIER cout << " "; // // Get a list of attribute pointers. The canonical output // format requires sorted attributes. If we aren't doing // canonical output, then we don't sort it, but we still use // the array. // const XMLAttr** attrTmp = new const XMLAttr*[attCount]; unsigned int index; for (index = 0; index < attCount; index++) attrTmp[index] = attrList.elementAt(index); if (attCount > 1) qsort(attrTmp, attCount, sizeof(XMLAttr*), attrComp); for (index = 0; index < attCount; index++) { const XMLAttr* curAttr = attrTmp[index]; showString(curAttr->getQName()); XERCES_STD_QUALIFIER cout << "=\""; showString(curAttr->getValue()); XERCES_STD_QUALIFIER cout << "\""; if (index < attCount-1) XERCES_STD_QUALIFIER cout << " "; } delete [] attrTmp; } if (isEmpty) { XERCES_STD_QUALIFIER cout << "></"; showString(elemDecl.getFullName()); XERCES_STD_QUALIFIER cout << ">"; } else { XERCES_STD_QUALIFIER cout << ">"; } } }
void XPathMatcher::startElement(const XMLElementDecl& elemDecl, const unsigned int urlId, const XMLCh* const elemPrefix, const RefVectorOf<XMLAttr>& attrList, const unsigned int attrCount) { for (int i = 0; i < (int) fLocationPathSize; i++) { // push context int startStep = fCurrentStep[i]; fStepIndexes->elementAt(i)->push(startStep); // try next xpath, if not matching if ((fMatched[i] & XP_MATCHED_D) == XP_MATCHED || fNoMatchDepth[i] > 0) { fNoMatchDepth[i]++; continue; } if((fMatched[i] & XP_MATCHED_D) == XP_MATCHED_D) { fMatched[i] = XP_MATCHED_DP; } // consume self::node() steps XercesLocationPath* locPath = fLocationPaths->elementAt(i); int stepSize = locPath->getStepSize(); while (fCurrentStep[i] < stepSize && locPath->getStep(fCurrentStep[i])->getAxisType() == XercesStep::SELF) { fCurrentStep[i]++; } if (fCurrentStep[i] == stepSize) { fMatched[i] = XP_MATCHED; continue; } // now if the current step is a descendant step, we let the next // step do its thing; if it fails, we reset ourselves // to look at this step for next time we're called. // so first consume all descendants: int descendantStep = fCurrentStep[i]; while (fCurrentStep[i] < stepSize && locPath->getStep(fCurrentStep[i])->getAxisType() == XercesStep::DESCENDANT) { fCurrentStep[i]++; } bool sawDescendant = fCurrentStep[i] > descendantStep; if (fCurrentStep[i] == stepSize) { fNoMatchDepth[i]++; continue; } // match child::... step, if haven't consumed any self::node() if ((fCurrentStep[i] == startStep || fCurrentStep[i] > descendantStep) && locPath->getStep(fCurrentStep[i])->getAxisType() == XercesStep::CHILD) { XercesStep* step = locPath->getStep(fCurrentStep[i]); XercesNodeTest* nodeTest = step->getNodeTest(); if (nodeTest->getType() == XercesNodeTest::QNAME) { QName elemQName(elemPrefix, elemDecl.getElementName()->getLocalPart(), urlId, fMemoryManager); // if (!(*(nodeTest->getName()) == *(elemDecl.getElementName()))) { if (!(*(nodeTest->getName()) == elemQName)) { if(fCurrentStep[i] > descendantStep) { fCurrentStep[i] = descendantStep; continue; } fNoMatchDepth[i]++; continue; } } fCurrentStep[i]++; } if (fCurrentStep[i] == stepSize) { if (sawDescendant) { fCurrentStep[i] = descendantStep; fMatched[i] = XP_MATCHED_D; } else { fMatched[i] = XP_MATCHED; } continue; } // match attribute::... step if (fCurrentStep[i] < stepSize && locPath->getStep(fCurrentStep[i])->getAxisType() == XercesStep::ATTRIBUTE) { if (attrCount) { XercesNodeTest* nodeTest = locPath->getStep(fCurrentStep[i])->getNodeTest(); for (unsigned int attrIndex = 0; attrIndex < attrCount; attrIndex++) { const XMLAttr* curDef = attrList.elementAt(attrIndex); if (nodeTest->getType() != XercesNodeTest::QNAME || (*(nodeTest->getName()) == *(curDef->getAttName()))) { fCurrentStep[i]++; if (fCurrentStep[i] == stepSize) { fMatched[i] = XP_MATCHED_A; int j=0; for(; j<i && ((fMatched[j] & XP_MATCHED) != XP_MATCHED); j++) ; if(j == i) { SchemaAttDef* attDef = ((SchemaElementDecl&) elemDecl).getAttDef(curDef->getName(), curDef->getURIId()); DatatypeValidator* dv = (attDef) ? attDef->getDatatypeValidator() : 0; matched(curDef->getValue(), dv, false); } } break; } } } if ((fMatched[i] & XP_MATCHED) != XP_MATCHED) { if(fCurrentStep[i] > descendantStep) { fCurrentStep[i] = descendantStep; continue; } fNoMatchDepth[i]++; } } } }