neilg 2003/11/21 14:38:20
Modified: c/src/xercesc/internal IGXMLScanner.cpp IGXMLScanner2.cpp
SGXMLScanner.cpp
Log:
Setting the stage for PSVI (element and attribute) implementation:
pointing out all places in scanners where validation updates need
to occur. Thanks to David Cargill.
Revision Changes Path
1.32 +67 -32 xml-xerces/c/src/xercesc/internal/IGXMLScanner.cpp
Index: IGXMLScanner.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/xercesc/internal/IGXMLScanner.cpp,v
retrieving revision 1.31
retrieving revision 1.32
diff -u -r1.31 -r1.32
--- IGXMLScanner.cpp 21 Nov 2003 14:46:56 -0000 1.31
+++ IGXMLScanner.cpp 21 Nov 2003 22:38:19 -0000 1.32
@@ -1131,10 +1131,9 @@
}
// reset xsi:type ComplexTypeInfo
- if (fGrammarType == Grammar::SchemaGrammarType) {
- // REVISIT XXX: should not be necessary
+ if (fGrammarType == Grammar::SchemaGrammarType) {
((SchemaElementDecl*)topElem->fThisElement)->reset();
- if (!isRoot && false)
+ if (!isRoot)
((SchemaElementDecl*)(fElemStack.topElement()->fThisElement))->
setXsiComplexTypeInfo(((SchemaValidator*)fValidator)->getCurrentTypeInfo());
}
@@ -2025,7 +2024,7 @@
// This method is called to scan a start tag when we are processing
// namespaces. There are two different versions of this method, one for
-// namespace aware processing an done for non-namespace aware processing.
+// namespace aware processing and one for non-namespace aware processing.
//
// This method is called after we've scanned the < of a start tag. So we
// have to get the element name, then scan the attributes, after which
@@ -2450,13 +2449,10 @@
fValidate = false;
fElemStack.setValidationFlag(fValidate);
}
- else if(fGrammarType == Grammar::SchemaGrammarType && fValidate) {
- ((SchemaElementDecl
*)(elemDecl))->setValidationAttempted(PSVIDefs::FULL);
- }
-
- // If validating then emit an error
- if (fValidate)
+ else if (fValidate)
{
+ // If validating then emit an error
+
// 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);
@@ -2468,7 +2464,16 @@
);
if(fGrammarType == Grammar::SchemaGrammarType)
- ((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
+ {
+ ((SchemaElementDecl
*)(elemDecl))->setValidationAttempted(PSVIDefs::FULL);
+ ((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);\
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIElement->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
+ }
}
}
else
@@ -2477,6 +2482,12 @@
if (fValidate) {
((SchemaElementDecl
*)(elemDecl))->setValidationAttempted(PSVIDefs::FULL);
((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::VALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIElement->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_VALID);
+ }
}
}
@@ -2486,6 +2497,12 @@
if(fGrammarType == Grammar::SchemaGrammarType) {
((SchemaElementDecl
*)(elemDecl))->setValidity(PSVIDefs::INVALID);
((SchemaElementDecl
*)(elemDecl))->setValidationAttempted(PSVIDefs::FULL);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIElement->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ // PSVIElement->setValidity(PSVIItem::VALIDATION_INVALID);
+ }
}
}
@@ -2493,7 +2510,7 @@
fValidate = false;
fElemStack.setValidationFlag(fValidate);
}
- if (fValidate)
+ else if (fValidate)
{
fValidator->emitError
(
@@ -2502,9 +2519,8 @@
);
}
}
-
- // REVISIT: XXX not necessary
- if (fGrammarType == Grammar::SchemaGrammarType && false) {
+
+ if (fGrammarType == Grammar::SchemaGrammarType) {
((SchemaElementDecl*)elemDecl)->setXsiComplexTypeInfo(0);
((SchemaElementDecl*)elemDecl)->setXsiSimpleTypeInfo(0);
}
@@ -2512,6 +2528,11 @@
if(errorBeforeElementFound && fGrammarType == Grammar::SchemaGrammarType) {
((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
@@ -2550,16 +2571,21 @@
(
XMLValid::GrammarNotFound
, prefixBuf.getRawBuffer()
- );
-
- if(fGrammarType == Grammar::SchemaGrammarType)
- ((SchemaElementDecl
*)(elemDecl))->setValidity(PSVIDefs::INVALID);
-
+ );
+ ((SchemaElementDecl
*)(elemDecl))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ //
PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
- else if(errorCondition) {
- if(fGrammarType == Grammar::SchemaGrammarType) {
- ((SchemaElementDecl
*)(elemDecl))->setValidationAttempted(PSVIDefs::NONE);
- ((SchemaElementDecl
*)(elemDecl))->setValidity(PSVIDefs::UNKNOWN);
+ else if(errorCondition) {
+ ((SchemaElementDecl
*)(elemDecl))->setValidationAttempted(PSVIDefs::NONE);
+ ((SchemaElementDecl
*)(elemDecl))->setValidity(PSVIDefs::UNKNOWN);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIElement->setValidationAttempted(PSVIItem::VALIDATION_NONE);
+ //
PSVIElement->setValidity(PSVIItem::VALIDITY_NOTKNOWN);
}
}
}
@@ -2594,8 +2620,14 @@
fValidator->emitError(XMLValid::RootElemNotLikeDocType);
if(fGrammarType == Grammar::SchemaGrammarType)
+ {
((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
-
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
+ }
}
}
else if (parentValidation)
@@ -2634,7 +2666,6 @@
count = fMatcherStack->getMatcherCount();
for (unsigned int j = 0; j < count; j++) {
-
XPathMatcher* matcher = fMatcherStack->getMatcherAt(j);
matcher->startElement(*elemDecl, uriId, fPrefixBuf.getRawBuffer(),
*fAttrList, attCount);
}
@@ -2678,8 +2709,14 @@
, elemDecl->getFormattedContentModel()
);
if(fGrammarType == Grammar::SchemaGrammarType)
+ {
((SchemaElementDecl
*)(elemDecl))->setValidity(PSVIDefs::INVALID);
-
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
+ }
}
if (fGrammarType == Grammar::SchemaGrammarType) {
@@ -2735,7 +2772,6 @@
if(!isRoot && fGrammarType == Grammar::SchemaGrammarType)
((SchemaElementDecl
*)fElemStack.topElement()->fThisElement)->updateValidityFromElement(elemDecl,
fGrammarType);
-
// If we have a doc handler, tell it about the end tag
if (fDocHandler)
{
@@ -2749,10 +2785,9 @@
}
// reset xsi:type ComplexTypeInfo
- if (fGrammarType == Grammar::SchemaGrammarType) {
- // REVISIT XXX: should not be necessary
+ if (fGrammarType == Grammar::SchemaGrammarType) {
((SchemaElementDecl*)elemDecl)->reset();
- if (!isRoot && false)
+ if (!isRoot)
((SchemaElementDecl*)(fElemStack.topElement()->fThisElement))->
setXsiComplexTypeInfo(((SchemaValidator*)fValidator)->getCurrentTypeInfo());
}
1.41 +124 -15 xml-xerces/c/src/xercesc/internal/IGXMLScanner2.cpp
Index: IGXMLScanner2.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/xercesc/internal/IGXMLScanner2.cpp,v
retrieving revision 1.40
retrieving revision 1.41
diff -u -r1.40 -r1.41
--- IGXMLScanner2.cpp 12 Nov 2003 20:29:47 -0000 1.40
+++ IGXMLScanner2.cpp 21 Nov 2003 22:38:19 -0000 1.41
@@ -258,6 +258,11 @@
);
if(fGrammarType == Grammar::SchemaGrammarType) {
((SchemaAttDef
*)(attDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
}
@@ -275,6 +280,11 @@
);
if(fGrammarType == Grammar::SchemaGrammarType) {
((SchemaAttDef
*)(attDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
}
@@ -300,10 +310,20 @@
if(!skipThisOne && fGrammarType == Grammar::SchemaGrammarType) {
//we may have set it to invalid already, but this is the first time
we are guarenteed to have the attDef
- if(((SchemaAttDef *)(attDef))->getValidity() != PSVIDefs::INVALID)
+ if(((SchemaAttDef *)(attDef))->getValidity() != PSVIDefs::INVALID)
((SchemaAttDef *)(attDef))->setValidity(PSVIDefs::VALID);
-
+ // REVISIT: need to check getValidity...
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
((SchemaAttDef *)(attDef))->setValidationAttempted(PSVIDefs::FULL);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ }
}
if (wasAdded)
@@ -342,11 +362,22 @@
);
if(fGrammarType == Grammar::SchemaGrammarType) {
((SchemaAttDef *)(attDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
else if(errorCondition && laxThisOne && fGrammarType ==
Grammar::SchemaGrammarType) {
((SchemaAttDef *)(attDef))->setValidationAttempted(PSVIDefs::NONE);
((SchemaAttDef *)(attDef))->setValidity(PSVIDefs::UNKNOWN);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_NOTKNOWN);
+ //
PSVIAttribute->setValidationAttempted(PSVIItem::VALIDATION_NONE);
+ }
}
@@ -362,6 +393,11 @@
);
if(fGrammarType == Grammar::SchemaGrammarType) {
((SchemaAttDef *)(attDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
else
@@ -554,6 +590,12 @@
if(fGrammarType == Grammar::SchemaGrammarType) {
((SchemaAttDef
*)curDef)->setValidationAttempted(PSVIDefs::FULL);
((SchemaAttDef *)curDef)->setValidity(PSVIDefs::VALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_VALID;
+ //
PSVIAttribute->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ }
}
//the attributes is not provided
@@ -570,7 +612,14 @@
, curDef->getFullName()
);
if(fGrammarType == Grammar::SchemaGrammarType)
+ {
((SchemaAttDef
*)(curDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
+ }
}
else if ((defType == XMLAttDef::Default) ||
(defType == XMLAttDef::Fixed) )
@@ -581,7 +630,14 @@
// Document is standalone, so attributes must not be
defaulted.
fValidator->emitError(XMLValid::NoDefAttForStandalone,
curDef->getFullName(), elemDecl->getFullName());
if(fGrammarType == Grammar::SchemaGrammarType)
+ {
((SchemaAttDef
*)(curDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
+ }
}
}
}
@@ -648,6 +704,12 @@
if(fGrammarType == Grammar::SchemaGrammarType) {
((SchemaAttDef *)(curDef))->setValidity(PSVIDefs::INVALID);
((SchemaElementDecl
*)elemDecl)->updateValidityFromAttribute((SchemaAttDef *)curDef);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ // new function?
+ }
}
}
}
@@ -721,13 +783,17 @@
// XML 1.0, Section 2.9
if (fStandalone && fValidate && isAttExternal)
{
- // Can't have a standalone document declaration of "yes"
if attribute
- // values are subject to normalisation
- fValidator->emitError(XMLValid::NoAttNormForStandalone,
attDef->getFullName());
- if(fGrammarType == Grammar::SchemaGrammarType) {
- ((SchemaAttDef
*)(attDef))->setValidity(PSVIDefs::INVALID);
- }
-
+ // Can't have a standalone document declaration of "yes" if
attribute
+ // values are subject to normalisation
+ fValidator->emitError(XMLValid::NoAttNormForStandalone,
attDef->getFullName());
+ if(fGrammarType == Grammar::SchemaGrammarType) {
+ ((SchemaAttDef
*)(attDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
+ }
}
nextCh = chSpace;
}
@@ -768,6 +834,11 @@
fValidator->emitError(XMLValid::NoAttNormForStandalone,
attDef->getFullName());
if(fGrammarType == Grammar::SchemaGrammarType) {
((SchemaAttDef
*)(attDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
}
@@ -1073,7 +1144,14 @@
// They definitely cannot handle any type of char data
fValidator->emitError(XMLValid::NoCharDataInCM);
if(fGrammarType == Grammar::SchemaGrammarType)
+ {
((SchemaElementDecl
*)topElem->fThisElement)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
+ }
}
else if (fReaderMgr.getCurrentReader()->isAllSpaces(rawBuf, len))
{
@@ -1166,7 +1244,14 @@
{
fValidator->emitError(XMLValid::NoCharDataInCM);
if(fGrammarType == Grammar::SchemaGrammarType)
+ {
((SchemaElementDecl
*)topElem->fThisElement)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
+ }
}
}
}
@@ -1998,12 +2083,17 @@
// XML 1.0, Section 2.9
if (fStandalone && fValidate && isAttExternal)
{
- // Can't have a standalone document declaration of
"yes" if attribute
- // values are subject to normalisation
-
fValidator->emitError(XMLValid::NoAttNormForStandalone, attrName);
+ // Can't have a standalone document declaration of
"yes" if attribute
+ // values are subject to normalisation
+ fValidator->emitError(XMLValid::NoAttNormForStandalone,
attrName);
- if(fGrammarType == Grammar::SchemaGrammarType) {
- ((SchemaAttDef
*)attDef)->setValidity(PSVIDefs::INVALID);
+ if(fGrammarType == Grammar::SchemaGrammarType) {
+ ((SchemaAttDef
*)attDef)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
nextCh = chSpace;
@@ -2147,7 +2237,14 @@
// element type with element content whose element declaration
was external
fValidator->emitError(XMLValid::NoWSForStandalone);
if(fGrammarType == Grammar::SchemaGrammarType)
+ {
((SchemaElementDecl
*)topElem->fThisElement)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
+ }
}
}
}
@@ -2186,6 +2283,11 @@
// They definitely cannot handle any type of char data
fValidator->emitError(XMLValid::NoCharDataInCM);
((SchemaElementDecl
*)topElem->fThisElement)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
@@ -2480,7 +2582,14 @@
//
fValidator->emitError(XMLValid::NoWSForStandalone);
if(fGrammarType == Grammar::SchemaGrammarType)
+ {
((SchemaElementDecl
*)fElemStack.topElement()->fThisElement)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
+ }
}
}
}
1.49 +163 -24 xml-xerces/c/src/xercesc/internal/SGXMLScanner.cpp
Index: SGXMLScanner.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/xercesc/internal/SGXMLScanner.cpp,v
retrieving revision 1.48
retrieving revision 1.49
diff -u -r1.48 -r1.49
--- SGXMLScanner.cpp 12 Nov 2003 20:29:47 -0000 1.48
+++ SGXMLScanner.cpp 21 Nov 2003 22:38:19 -0000 1.49
@@ -1059,12 +1059,9 @@
);
}
-
- // reset xsi:type ComplexTypeInfo
- // REVISIT mutability!
+ // reset xsi:type ComplexTypeInfo
((SchemaElementDecl*)topElem->fThisElement)->reset();
- // XXX
- if (!isRoot && false)
+ if (!isRoot)
((SchemaElementDecl*)(fElemStack.topElement()->fThisElement))->
setXsiComplexTypeInfo(((SchemaValidator*)fValidator)->getCurrentTypeInfo());
@@ -1449,6 +1446,11 @@
}
else if(fValidate) {
((SchemaElementDecl
*)(elemDecl))->setValidationAttempted(PSVIDefs::FULL);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ }
}
// If validating then emit an error
@@ -1464,7 +1466,11 @@
, elemDecl->getFullName()
);
((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
-
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
else
@@ -1473,6 +1479,12 @@
if (fValidate) {
((SchemaElementDecl
*)(elemDecl))->setValidationAttempted(PSVIDefs::FULL);
((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::VALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIElement->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_VALID);
+ }
}
}
@@ -1481,6 +1493,12 @@
if(elemDecl->getCreateReason() == XMLElementDecl::NoReason) {
((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
((SchemaElementDecl
*)(elemDecl))->setValidationAttempted(PSVIDefs::FULL);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIElement->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
if (laxThisOne) {
fValidate = false;
@@ -1496,8 +1514,7 @@
);
}
}
-
- // XXX REVISIT: should not be necessary
+
((SchemaElementDecl*)elemDecl)->setXsiComplexTypeInfo(0);
((SchemaElementDecl*)elemDecl)->setXsiSimpleTypeInfo(0);
}
@@ -1505,6 +1522,11 @@
if(errorBeforeElementFound) {
((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
// Now we can update the element stack to set the current element
@@ -1544,12 +1566,22 @@
, prefixBuf.getRawBuffer()
);
((SchemaElementDecl
*)(elemDecl))->setValidity(PSVIDefs::INVALID);
-
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
else if(errorCondition) {
((SchemaElementDecl
*)(elemDecl))->setValidationAttempted(PSVIDefs::NONE);
((SchemaElementDecl
*)(elemDecl))->setValidity(PSVIDefs::UNKNOWN);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIElement->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_NOTKNOWN);
+ }
}
}
@@ -1576,6 +1608,11 @@
if (fValidatorFromUser &&
!fValidator->checkRootElement(elemDecl->getId())) {
fValidator->emitError(XMLValid::RootElemNotLikeDocType);
((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
}
@@ -1661,6 +1698,11 @@
, elemDecl->getFormattedContentModel()
);
((SchemaElementDecl *)(elemDecl))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
// call matchers and de-activate context
@@ -1724,10 +1766,9 @@
);
}
- // reset xsi:type ComplexTypeInfo
- // REVISIT XXX; should not be necessary
+ // reset xsi:type ComplexTypeInfo
((SchemaElementDecl*)elemDecl)->reset();
- if (!isRoot && false)
+ if (!isRoot)
((SchemaElementDecl*)(fElemStack.topElement()->fThisElement))->
setXsiComplexTypeInfo(((SchemaValidator*)fValidator)->getCurrentTypeInfo());
@@ -2159,6 +2200,11 @@
, attDef->getFullName()
);
((SchemaAttDef
*)(attDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
else {
@@ -2173,6 +2219,11 @@
, attDef->getFullName()
);
((SchemaAttDef
*)(attDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
}
@@ -2198,9 +2249,21 @@
if(!skipThisOne && fGrammarType == Grammar::SchemaGrammarType) {
//we may have set it to invalid already, but this is the first time
we are guarenteed to have the attDef
if(((SchemaAttDef *)(attDef))->getValidity() != PSVIDefs::INVALID)
- ((SchemaAttDef *)(attDef))->setValidity(PSVIDefs::VALID);
-
+ {
+ ((SchemaAttDef *)(attDef))->setValidity(PSVIDefs::VALID);
+ }
+ // REVISIT: need to check out value...
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_VALID);
+ }
((SchemaAttDef *)(attDef))->setValidationAttempted(PSVIDefs::FULL);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ }
}
if (wasAdded)
@@ -2238,10 +2301,21 @@
, elemDecl->getFullName()
);
((SchemaAttDef *)attDef)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
else if(errorCondition && laxThisOne) {
((SchemaAttDef *)(attDef))->setValidationAttempted(PSVIDefs::NONE);
((SchemaAttDef *)(attDef))->setValidity(PSVIDefs::UNKNOWN);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidationAttempted(PSVIItem::VALIDATION_NONE);
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_NOTKNOWN);
+ }
}
@@ -2256,6 +2330,11 @@
, elemDecl->getFullName()
);
((SchemaAttDef *)(attDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
else
@@ -2421,6 +2500,12 @@
{
((SchemaAttDef *)curDef)->setValidationAttempted(PSVIDefs::FULL);
((SchemaAttDef *)curDef)->setValidity(PSVIDefs::VALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidationAttempted(PSVIItem::VALIDATION_FULL);
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_VALID);
+ }
//the attributes is not provided
if (fValidate)
@@ -2436,6 +2521,11 @@
, curDef->getFullName()
);
((SchemaAttDef *)(curDef))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
else if ((defType == XMLAttDef::Default) ||
(defType == XMLAttDef::Fixed) )
@@ -2446,7 +2536,11 @@
// Document is standalone, so attributes must not be
defaulted.
fValidator->emitError(XMLValid::NoDefAttForStandalone,
curDef->getFullName(), elemDecl->getFullName());
((SchemaAttDef
*)(curDef))->setValidity(PSVIDefs::INVALID);
-
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
}
@@ -2499,6 +2593,11 @@
, curDef->getFullName()
);
((SchemaAttDef *)curDef)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
((SchemaElementDecl
*)elemDecl)->updateValidityFromAttribute((SchemaAttDef *)curDef);
}
@@ -2574,10 +2673,15 @@
// XML 1.0, Section 2.9
if (fStandalone && fValidate && isAttExternal)
{
- // Can't have a standalone document declaration of "yes"
if attribute
- // values are subject to normalisation
- fValidator->emitError(XMLValid::NoAttNormForStandalone,
attrName);
- ((SchemaAttDef *)attDef)->setValidity(PSVIDefs::INVALID);
+ // Can't have a standalone document declaration of "yes" if
attribute
+ // values are subject to normalisation
+ fValidator->emitError(XMLValid::NoAttNormForStandalone,
attrName);
+ ((SchemaAttDef *)attDef)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
nextCh = chSpace;
}
@@ -2613,10 +2717,15 @@
{
if (!firstNonWS || (nextCh != chSpace) || (!*srcPtr) ||
fReaderMgr.getCurrentReader()->isWhitespace(*srcPtr))
{
- // Can't have a standalone document declaration of
"yes" if attribute
- // values are subject to normalisation
-
fValidator->emitError(XMLValid::NoAttNormForStandalone, attrName);
- ((SchemaAttDef
*)attDef)->setValidity(PSVIDefs::INVALID);
+ // Can't have a standalone document declaration of
"yes" if attribute
+ // values are subject to normalisation
+ fValidator->emitError(XMLValid::NoAttNormForStandalone,
attrName);
+ ((SchemaAttDef
*)attDef)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
continue;
@@ -2894,6 +3003,11 @@
// They definitely cannot handle any type of char data
fValidator->emitError(XMLValid::NoCharDataInCM);
((SchemaElementDecl
*)topElem->fThisElement)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
else if (fReaderMgr.getCurrentReader()->isAllSpaces(rawBuf, len))
{
@@ -2978,6 +3092,11 @@
{
fValidator->emitError(XMLValid::NoCharDataInCM);
((SchemaElementDecl
*)topElem->fThisElement)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
}
@@ -3701,6 +3820,11 @@
// element type with element content whose element declaration
was external
fValidator->emitError(XMLValid::NoWSForStandalone);
((SchemaElementDecl
*)(topElem->fThisElement))->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
}
@@ -3737,6 +3861,11 @@
// They definitely cannot handle any type of char data
fValidator->emitError(XMLValid::NoCharDataInCM);
((SchemaElementDecl
*)topElem->fThisElement)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
@@ -4015,6 +4144,11 @@
//
fValidator->emitError(XMLValid::NoWSForStandalone);
((SchemaElementDecl
*)fElemStack.topElement()->fThisElement)->setValidity(PSVIDefs::INVALID);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
+ }
}
}
}
@@ -4267,6 +4401,11 @@
// attribute should just be bypassed,
skipThisOne = true;
attWildCard->setValidationAttempted(PSVIDefs::NONE);
+ if (getPSVIHandler())
+ {
+ // REVISIT:
+ //
PSVIAttribute->setValidationAttempted(PSVIItem::VALIDATION_NONE);
+ }
}
else if (defType == XMLAttDef::ProcessContents_Lax) {
laxThisOne = true;
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
