You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by kn...@apache.org on 2001/05/11 23:51:24 UTC
cvs commit: xml-xerces/c/src/validators/schema TraverseSchema.cpp TraverseSchema.hpp
knoaman 01/05/11 14:51:24
Modified: c/src/util/regx ParserForXMLSchema.cpp
ParserForXMLSchema.hpp RegularExpression.cpp
RegxParser.cpp RegxParser.hpp
c/src/validators/datatype DatatypeValidator.cpp
DatatypeValidator.hpp DatatypeValidatorFactory.cpp
c/src/validators/schema TraverseSchema.cpp
TraverseSchema.hpp
Log:
Schema updates and fixes.
Revision Changes Path
1.4 +115 -0 xml-xerces/c/src/util/regx/ParserForXMLSchema.cpp
Index: ParserForXMLSchema.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/util/regx/ParserForXMLSchema.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- ParserForXMLSchema.cpp 2001/05/11 13:26:44 1.3
+++ ParserForXMLSchema.cpp 2001/05/11 21:50:56 1.4
@@ -56,6 +56,9 @@
/*
* $Log: ParserForXMLSchema.cpp,v $
+ * Revision 1.4 2001/05/11 21:50:56 knoaman
+ * Schema updates and fixes.
+ *
* Revision 1.3 2001/05/11 13:26:44 tng
* Copyright update.
*
@@ -88,6 +91,7 @@
#include <util/regx/TokenInc.hpp>
#include <util/regx/RegxDefs.hpp>
#include <util/ParseException.hpp>
+#include <util/RuntimeException.hpp>
// ---------------------------------------------------------------------------
// ParserForXMLSchema: Constructors and Destructors
@@ -328,6 +332,111 @@
return -1;
}
+Token* ParserForXMLSchema::processLook(const unsigned short tokType) {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_A() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_B() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_b() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_C() {
+
+ processNext();
+ return getTokenForShorthand(chLatin_C);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_c() {
+
+ processNext();
+ return getTokenForShorthand(chLatin_c);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_g() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_gt() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_I() {
+
+ processNext();
+ return getTokenForShorthand(chLatin_I);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_i() {
+
+ processNext();
+ return getTokenForShorthand(chLatin_i);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_lt() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_X() {
+
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_Z() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processBacksolidus_z() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processBackReference() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processCondition() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processIndependent() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processModifiers() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+Token* ParserForXMLSchema::processParen2() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
+RangeToken* ParserForXMLSchema::parseSetOperations() {
+
+ ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
+}
+
// ---------------------------------------------------------------------------
// ParserForXMLSchema: Getter methods
// ---------------------------------------------------------------------------
@@ -362,6 +471,12 @@
// ---------------------------------------------------------------------------
// ParserForXMLSchema: Helper methods
// ---------------------------------------------------------------------------
+bool ParserForXMLSchema::checkQuestion(const int off) {
+
+ return false;
+}
+
+
XMLInt32 ParserForXMLSchema::decodeEscaped() {
if (getState() != T_BACKSOLIDUS)
1.4 +1 -118 xml-xerces/c/src/util/regx/ParserForXMLSchema.hpp
Index: ParserForXMLSchema.hpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/util/regx/ParserForXMLSchema.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- ParserForXMLSchema.hpp 2001/05/11 13:26:45 1.3
+++ ParserForXMLSchema.hpp 2001/05/11 21:50:57 1.4
@@ -55,7 +55,7 @@
*/
/*
- * $Id: ParserForXMLSchema.hpp,v 1.3 2001/05/11 13:26:45 tng Exp $
+ * $Id: ParserForXMLSchema.hpp,v 1.4 2001/05/11 21:50:57 knoaman Exp $
*/
#if !defined(PARSERFORXMLSCHEMA_HPP)
@@ -65,7 +65,6 @@
// Includes
// ---------------------------------------------------------------------------
#include <util/regx/RegxParser.hpp>
-#include <util/RuntimeException.hpp>
// ---------------------------------------------------------------------------
// Forward Declaration
@@ -142,122 +141,6 @@
// -----------------------------------------------------------------------
};
-// ---------------------------------------------------------------------------
-// ParserForXMLSchema: Helper methods
-// ---------------------------------------------------------------------------
-inline bool ParserForXMLSchema::checkQuestion(const int off) {
-
- return false;
-}
-
-
-// ---------------------------------------------------------------------------
-// ParserForXMLSchema: Parsing/Processing methods
-// ---------------------------------------------------------------------------
-inline Token* ParserForXMLSchema::processLook(const unsigned short tokType) {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_A() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_B() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_b() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_C() {
-
- processNext();
- return getTokenForShorthand(chLatin_C);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_c() {
-
- processNext();
- return getTokenForShorthand(chLatin_c);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_g() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_gt() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_I() {
-
- processNext();
- return getTokenForShorthand(chLatin_I);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_i() {
-
- processNext();
- return getTokenForShorthand(chLatin_i);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_lt() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_X() {
-
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_Z() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processBacksolidus_z() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processBackReference() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processCondition() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processIndependent() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processModifiers() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline Token* ParserForXMLSchema::processParen2() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
-
-inline RangeToken* ParserForXMLSchema::parseSetOperations() {
-
- ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
-}
#endif
/**
1.4 +13 -5 xml-xerces/c/src/util/regx/RegularExpression.cpp
Index: RegularExpression.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/util/regx/RegularExpression.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- RegularExpression.cpp 2001/05/11 13:26:46 1.3
+++ RegularExpression.cpp 2001/05/11 21:50:58 1.4
@@ -56,6 +56,9 @@
/*
* $Log: RegularExpression.cpp,v $
+ * Revision 1.4 2001/05/11 21:50:58 knoaman
+ * Schema updates and fixes.
+ *
* Revision 1.3 2001/05/11 13:26:46 tng
* Copyright update.
*
@@ -837,6 +840,7 @@
return false;
}
+ offset = (direction > 0) ? ++tmpOffset : tmpOffset;
return true;
}
@@ -1014,18 +1018,22 @@
const short direction, const bool ignoreCase)
{
int length = XMLString::stringLen(literal);
+ int tmpOffset = (direction > 0) ? offset : offset - length;
- if (context->fLimit - offset < length)
+ if (context->fLimit - tmpOffset < length)
return false;
bool match = ignoreCase
- ? XMLString::regionIMatches(context->fString, offset,
+ ? XMLString::regionIMatches(context->fString, tmpOffset,
literal, 0, length)
- : XMLString::regionMatches(context->fString, offset,
+ : XMLString::regionMatches(context->fString, tmpOffset,
literal, 0, length);
- offset = direction > 0 ? offset + length : offset - length;
- return true;
+ if (match) {
+ offset = direction > 0 ? offset + length : offset - length;
+ }
+
+ return match;
}
int RegularExpression::matchCapture(Context* const context, const Op* const op,
1.4 +12 -1 xml-xerces/c/src/util/regx/RegxParser.cpp
Index: RegxParser.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/util/regx/RegxParser.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- RegxParser.cpp 2001/05/11 13:26:48 1.3
+++ RegxParser.cpp 2001/05/11 21:51:01 1.4
@@ -56,6 +56,9 @@
/*
* $Log: RegxParser.cpp,v $
+ * Revision 1.4 2001/05/11 21:51:01 knoaman
+ * Schema updates and fixes.
+ *
* Revision 1.3 2001/05/11 13:26:48 tng
* Copyright update.
*
@@ -100,7 +103,7 @@
const unsigned short RegxParser::S_INXBRACKETS = 2;
// ---------------------------------------------------------------------------
-// RegularExpression::ReferencePostion: Constructors and Destructor
+// RegxParser::ReferencePostion: Constructors and Destructor
// ---------------------------------------------------------------------------
RegxParser::ReferencePosition::ReferencePosition(const int refNo,
const int position)
@@ -1466,6 +1469,14 @@
} // end switch
return ch;
+}
+
+// ---------------------------------------------------------------------------
+// RegxParser: Helper Methods
+// ---------------------------------------------------------------------------
+bool RegxParser::checkQuestion(const int off) {
+
+ return ((off < fStringLen) && fString[off] == chQuestion);
}
/**
1.5 +1 -5 xml-xerces/c/src/util/regx/RegxParser.hpp
Index: RegxParser.hpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/util/regx/RegxParser.hpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- RegxParser.hpp 2001/05/11 13:26:49 1.4
+++ RegxParser.hpp 2001/05/11 21:51:02 1.5
@@ -55,7 +55,7 @@
*/
/*
- * $Id: RegxParser.hpp,v 1.4 2001/05/11 13:26:49 tng Exp $
+ * $Id: RegxParser.hpp,v 1.5 2001/05/11 21:51:02 knoaman Exp $
*/
/*
@@ -295,10 +295,6 @@
return (fOptions & flag) == flag;
}
-inline bool RegxParser::checkQuestion(const int off) {
-
- return off < fStringLen && fString[off] == chQuestion;
-}
inline int RegxParser::hexChar(const XMLInt32 ch) {
1.6 +5 -2 xml-xerces/c/src/validators/datatype/DatatypeValidator.cpp
Index: DatatypeValidator.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/validators/datatype/DatatypeValidator.cpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- DatatypeValidator.cpp 2001/05/11 13:27:27 1.5
+++ DatatypeValidator.cpp 2001/05/11 21:51:09 1.6
@@ -56,6 +56,9 @@
/*
* $Log: DatatypeValidator.cpp,v $
+ * Revision 1.6 2001/05/11 21:51:09 knoaman
+ * Schema updates and fixes.
+ *
* Revision 1.5 2001/05/11 13:27:27 tng
* Copyright update.
*
@@ -88,10 +91,10 @@
const int finalSet,
const ValidatorType type)
: fFinalSet(finalSet)
+ , fFacetsDefined(0)
+ , fType(type)
, fBaseValidator(baseValidator)
, fFacets(facets)
- , fType(type)
- , fFacetsDefined(0)
, fPattern(0)
, fRegex(0)
{
1.6 +8 -10 xml-xerces/c/src/validators/datatype/DatatypeValidator.hpp
Index: DatatypeValidator.hpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/validators/datatype/DatatypeValidator.hpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- DatatypeValidator.hpp 2001/05/11 13:27:27 1.5
+++ DatatypeValidator.hpp 2001/05/11 21:51:11 1.6
@@ -55,7 +55,7 @@
*/
/*
- * $Id: DatatypeValidator.hpp,v 1.5 2001/05/11 13:27:27 tng Exp $
+ * $Id: DatatypeValidator.hpp,v 1.6 2001/05/11 21:51:11 knoaman Exp $
*/
#if !defined(DATATYPEVALIDATOR_HPP)
@@ -335,15 +335,12 @@
// -----------------------------------------------------------------------
int fFinalSet;
+ int fFacetsDefined;
+ ValidatorType fType;
DatatypeValidator* fBaseValidator;
RefHashTableOf<KVStringPair>* fFacets;
-
- ValidatorType fType;
- int fFacetsDefined;
- const XMLCh* fPattern;
- RegularExpression *fRegex;
-
- //ValueVectorOf<bool> *fFixed;
+ XMLCh* fPattern;
+ RegularExpression* fRegex;
};
@@ -386,8 +383,8 @@
inline void DatatypeValidator::cleanUp() {
delete fFacets;
+ delete [] fPattern;
delete fRegex;
-
}
@@ -437,7 +434,8 @@
inline void DatatypeValidator::setPattern(const XMLCh* pattern)
{
- fPattern = pattern;
+ delete [] fPattern;
+ fPattern = XMLString::replicate(pattern);
}
inline RegularExpression* DatatypeValidator::getRegex() const
1.5 +61 -123 xml-xerces/c/src/validators/datatype/DatatypeValidatorFactory.cpp
Index: DatatypeValidatorFactory.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/validators/datatype/DatatypeValidatorFactory.cpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- DatatypeValidatorFactory.cpp 2001/05/11 13:27:28 1.4
+++ DatatypeValidatorFactory.cpp 2001/05/11 21:51:13 1.5
@@ -56,6 +56,9 @@
/*
* $Log: DatatypeValidatorFactory.cpp,v $
+ * Revision 1.5 2001/05/11 21:51:13 knoaman
+ * Schema updates and fixes.
+ *
* Revision 1.4 2001/05/11 13:27:28 tng
* Copyright update.
*
@@ -80,18 +83,19 @@
#include <util/Janitor.hpp>
#include <validators/datatype/StringDatatypeValidator.hpp>
#include <validators/datatype/BooleanDatatypeValidator.hpp>
+#include <validators/datatype/DecimalDatatypeValidator.hpp>
// ---------------------------------------------------------------------------
// DatatypeValidatorFactory: Local const data
// ---------------------------------------------------------------------------
-const XMLCh fgTokPattern[] =
-{
+const XMLCh fgTokPattern[] =
+{
chBackSlash, chLatin_c, chPlus, chNull
};
//"([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]+)(-[a-zA-Z]+)*"
-const XMLCh fgLangPattern[] =
+const XMLCh fgLangPattern[] =
{
chOpenParen, chOpenSquare, chLatin_a, chDash, chLatin_z, chLatin_A, chDash,
chLatin_Z, chCloseSquare, chOpenCurly, chDigit_2, chCloseCurly, chPipe,
@@ -118,7 +122,7 @@
chColon, chCloseSquare, chCloseSquare, chAsterisk, chNull
};
-const XMLCh fgValueZero[] =
+const XMLCh fgValueZero[] =
{
chDigit_0, chNull
};
@@ -128,7 +132,7 @@
chDash, chDigit_1, chNull
};
-const XMLCh fgValueOne[] =
+const XMLCh fgValueOne[] =
{
chDigit_1, chNull
};
@@ -287,7 +291,7 @@
*/
// Create 'IDREFS' datatype validator
- createDatatypeValidator(XMLUni::fgIDRefsString,
+ createDatatypeValidator(XMLUni::fgIDRefsString,
getDatatypeValidator(XMLUni::fgIDRefString), 0, true);
// Create 'ENTITIES' datatype validator
@@ -295,7 +299,6 @@
getDatatypeValidator(XMLUni::fgEntityString), 0, true);
RefHashTableOf<KVStringPair>* facets = new RefHashTableOf<KVStringPair>(3);
- Janitor<KVStringPairHashTable> janFacets(facets);
facets->put((void*) SchemaSymbols::fgELT_PATTERN ,
new KVStringPair(SchemaSymbols::fgELT_PATTERN,fgTokPattern));
@@ -303,11 +306,8 @@
new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
// Create 'NMTOKEN' datatype validator
- if (createDatatypeValidator(XMLUni::fgNmTokenString,
- getDatatypeValidator(SchemaSymbols::fgDT_STRING),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ createDatatypeValidator(XMLUni::fgNmTokenString,
+ getDatatypeValidator(SchemaSymbols::fgDT_STRING),facets, false);
// Create 'NMTOKENS' datatype validator
createDatatypeValidator(XMLUni::fgNmTokensString,
@@ -334,15 +334,15 @@
}
try {
- fRegistry->put((void*) SchemaSymbols::fgDT_BOOLEAN,
+ fRegistry->put((void*) SchemaSymbols::fgDT_BOOLEAN,
new BooleanDatatypeValidator());
+ fRegistry->put((void*) SchemaSymbols::fgDT_DECIMAL,
+ new DecimalDatatypeValidator());
/*
fRegistry->put((void*) SchemaSymbols::fgDT_FLOAT,
new FloatDatatypeValidator());
fRegistry->put((void*) SchemaSymbols::fgDT_DOUBLE,
new DoubleDatatypeValidator());
- fRegistry->put((void*) SchemaSymbols::fgDT_DECIMAL,
- new DecimalDatatypeValidator());
fRegistry->put((void*) SchemaSymbols::fgDT_HEXBINARY,
new HexBinaryDatatypeValidator());
fRegistry->put((void*) SchemaSymbols::fgDT_BASE64BINARY,
@@ -354,7 +354,7 @@
fRegistry->put((void*) SchemaSymbols::fgDT_DURATION,
new DurationDatatypeValidator());
fRegistry->put((void*) SchemaSymbols::fgDT_DAY,
- new DayDatatypeValidator());
+ new DayDatatypeValidator());
fRegistry->put((void*) SchemaSymbols::fgDT_TIME,
new TimeDatatypeValidator());
*/
@@ -364,256 +364,194 @@
// validators. It's better to have some kind of a memory pool and ask
// the pool to give us a new instance of the hashtable.
-
- // Since the datatype validator is responsible for deleting the
- // facets hashtable, we have the potential of a memory leak if
- // an exception is thrown or we failed to create the datatype
- // validator.
- // We will use a janitor object to take care of any potential memory
- // leaks. After each succesful datatype creation, we will orphan the
- // janitor, and then reset it with the new hashtable.
-
// Create 'normalizedString' datatype validator
RefHashTableOf<KVStringPair>* facets = new RefHashTableOf<KVStringPair>(3);
- Janitor<KVStringPairHashTable> janFacets(facets);
facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_REPLACE));
- if (createDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING,
+ createDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING,
getDatatypeValidator(SchemaSymbols::fgDT_STRING),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'token' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
- if (createDatatypeValidator(SchemaSymbols::fgDT_TOKEN,
+ createDatatypeValidator(SchemaSymbols::fgDT_TOKEN,
getDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'language' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_PATTERN,
new KVStringPair(SchemaSymbols::fgELT_PATTERN, fgLangPattern));
- if (createDatatypeValidator(SchemaSymbols::fgDT_LANGUAGE,
+ createDatatypeValidator(SchemaSymbols::fgDT_LANGUAGE,
getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),
- facets, false ) != 0) {
- janFacets.orphan();
- }
+ facets, false );
// Create 'Name' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_PATTERN,
new KVStringPair(SchemaSymbols::fgELT_PATTERN, fgNamePattern));
- if (createDatatypeValidator(SchemaSymbols::fgDT_NAME,
+ createDatatypeValidator(SchemaSymbols::fgDT_NAME,
getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),
- facets, false ) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create a 'NCName' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_PATTERN,
new KVStringPair(SchemaSymbols::fgELT_PATTERN, fgNCNamePattern));
- if (createDatatypeValidator(SchemaSymbols::fgDT_NCNAME,
+ createDatatypeValidator(SchemaSymbols::fgDT_NCNAME,
getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'integer' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_FRACTIONDIGITS,
new KVStringPair(SchemaSymbols::fgELT_FRACTIONDIGITS, fgValueZero));
- if (createDatatypeValidator(SchemaSymbols::fgDT_INTEGER,
+ createDatatypeValidator(SchemaSymbols::fgDT_INTEGER,
getDatatypeValidator(SchemaSymbols::fgDT_DECIMAL),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
+/*
// Create 'nonPositiveInteger' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, fgValueZero));
- if (createDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER,
+ createDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER,
getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'negativeInteger' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE,fgNegOne));
- if (createDatatypeValidator(SchemaSymbols::fgDT_NEGATIVEINTEGER,
+ createDatatypeValidator(SchemaSymbols::fgDT_NEGATIVEINTEGER,
getDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'long' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE,fgLongMaxInc));
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE,fgLongMinInc));
- if (createDatatypeValidator(SchemaSymbols::fgDT_LONG,
+ createDatatypeValidator(SchemaSymbols::fgDT_LONG,
getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'int' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, fgIntMaxInc));
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, fgIntMinInc));
- if (createDatatypeValidator(SchemaSymbols::fgDT_INT,
+ createDatatypeValidator(SchemaSymbols::fgDT_INT,
getDatatypeValidator(SchemaSymbols::fgDT_LONG),
- facets,false) != 0) {
- janFacets.orphan();
- }
+ facets,false);
// Create 'short' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, fgShortMaxInc));
- facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
+ facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, fgShortMinInc));
- if (createDatatypeValidator(SchemaSymbols::fgDT_SHORT,
- getDatatypeValidator(SchemaSymbols::fgDT_INT),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ createDatatypeValidator(SchemaSymbols::fgDT_SHORT,
+ getDatatypeValidator(SchemaSymbols::fgDT_INT),
+ facets, false);
// Create 'byte' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, fgByteMaxInc));
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, fgByteMinInc));
- if (createDatatypeValidator(SchemaSymbols::fgDT_BYTE,
+ createDatatypeValidator(SchemaSymbols::fgDT_BYTE,
getDatatypeValidator(SchemaSymbols::fgDT_SHORT),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'nonNegativeInteger' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, fgValueZero));
- if (createDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER,
+ createDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER,
getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'unsignedLong' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, fgULongMaxInc));
- if (createDatatypeValidator(SchemaSymbols::fgDT_ULONG,
+ createDatatypeValidator(SchemaSymbols::fgDT_ULONG,
getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'unsignedInt' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, fgUIntMaxInc));
- if (createDatatypeValidator(SchemaSymbols::fgDT_UINT,
+ createDatatypeValidator(SchemaSymbols::fgDT_UINT,
getDatatypeValidator(SchemaSymbols::fgDT_ULONG),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'unsignedShort' datatypeValidator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, fgUShortMaxInc));
- if (createDatatypeValidator(SchemaSymbols::fgDT_USHORT,
+ createDatatypeValidator(SchemaSymbols::fgDT_USHORT,
getDatatypeValidator(SchemaSymbols::fgDT_UINT),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'unsignedByte' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, fgUByteMaxInc));
- if (createDatatypeValidator(SchemaSymbols::fgDT_UBYTE,
+ createDatatypeValidator(SchemaSymbols::fgDT_UBYTE,
getDatatypeValidator(SchemaSymbols::fgDT_USHORT),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// Create 'positiveInteger' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
- janFacets.reset(facets);
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, fgValueOne));
- if (createDatatypeValidator(SchemaSymbols::fgDT_POSITIVEINTEGER,
+ createDatatypeValidator(SchemaSymbols::fgDT_POSITIVEINTEGER,
getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
- facets, false) != 0) {
- janFacets.orphan();
- }
+ facets, false);
// REVISIT - Add the remaining datatype validators
// Create 'dateTime' datatype validator
@@ -627,8 +565,8 @@
// Create 'gYear' datatype validator
// Create 'gMonth' datatype validator
+*/
-
fRegistryExpanded = true;
}
catch(...){
@@ -639,8 +577,8 @@
// ---------------------------------------------------------------------------
// DatatypeValidatorFactory: factory methods
// ---------------------------------------------------------------------------
-DatatypeValidator*
-DatatypeValidatorFactory::createDatatypeValidator(const XMLCh* const typeName,
+DatatypeValidator*
+DatatypeValidatorFactory::createDatatypeValidator(const XMLCh* const typeName,
DatatypeValidator* const baseValidator,
RefHashTableOf<KVStringPair>* const facets,
const bool derivedByList,
@@ -658,14 +596,14 @@
}
else {
- if (baseValidator->getType() != DatatypeValidator::String) {
+ if ((baseValidator->getType() != DatatypeValidator::String) && facets) {
KVStringPair* value = facets->get(SchemaSymbols::fgELT_WHITESPACE);
if (value != 0) {
facets->removeKey(SchemaSymbols::fgELT_WHITESPACE);
}
- }
+ }
datatypeValidator = baseValidator->newInstance(baseValidator, facets, finalSet);
}
@@ -691,7 +629,7 @@
//datatypeValidator = new UnionDatatypeValidator(validators, finalSet);
if (datatypeValidator != 0) {
- fRegistry->put((void*) typeName, datatypeValidator);
+ fRegistry->put((void*) typeName, datatypeValidator);
}
return datatypeValidator;
1.5 +231 -226 xml-xerces/c/src/validators/schema/TraverseSchema.cpp
Index: TraverseSchema.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/validators/schema/TraverseSchema.cpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- TraverseSchema.cpp 2001/05/11 13:27:38 1.4
+++ TraverseSchema.cpp 2001/05/11 21:51:19 1.5
@@ -56,6 +56,9 @@
/*
* $Log: TraverseSchema.cpp,v $
+ * Revision 1.5 2001/05/11 21:51:19 knoaman
+ * Schema updates and fixes.
+ *
* Revision 1.4 2001/05/11 13:27:38 tng
* Copyright update.
*
@@ -123,12 +126,12 @@
chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chColon, chNull
};
-const XMLCh fgAnonSNamePrefix[] =
+const XMLCh fgAnonSNamePrefix[] =
{
chLatin_S, chNull
};
-const XMLCh fgAnonCNamePrefix[] =
+const XMLCh fgAnonCNamePrefix[] =
{
chLatin_C, chNull
};
@@ -259,8 +262,8 @@
}
else{
- // for complex type registry, attribute decl registry and
- // namespace mapping, needs to check whether the passed in
+ // for complex type registry, attribute decl registry and
+ // namespace mapping, needs to check whether the passed in
// Grammar was a newly instantiated one.
fComplexTypeRegistry = fSchemaGrammar->getComplexTypeRegistry();
@@ -290,7 +293,7 @@
fSchemaGrammar->setDatatypeRegistry(fDatatypeRegistry);
fSchemaGrammar->setTargetNamespace(fTargetNSURIString);
- fGrammarResolver->putGrammar(fSchemaGrammar->getTargetNamespace(),
+ fGrammarResolver->putGrammar(fSchemaGrammar->getTargetNamespace(),
fSchemaGrammar);
} // end else
@@ -308,9 +311,9 @@
retrieveNamespaceMapping();
- fElementDefaultQualified =
+ fElementDefaultQualified =
fSchemaRootElement.getAttribute(SchemaSymbols::fgATT_ELEMENTFORMDEFAULT).equals(SchemaSymbols::fgATTVAL_QUALIFIED);
- fAttributeDefaultQualified =
+ fAttributeDefaultQualified =
fSchemaRootElement.getAttribute(SchemaSymbols::fgATT_ATTRIBUTEFORMDEFAULT).equals(SchemaSymbols::fgATTVAL_QUALIFIED);
// Get finalDefault/blockDefault values
@@ -334,9 +337,9 @@
/**
* Traverse include
*
- * <include
- * id = ID
- * schemaLocation = anyURI
+ * <include
+ * id = ID
+ * schemaLocation = anyURI
* {any attributes with non-schema namespace . . .}>
* Content: (annotation?)
* </include>
@@ -353,7 +356,7 @@
// ------------------------------------------------------------------
// Get 'schemaLocation' attribute
// ------------------------------------------------------------------
- const XMLCh* schemaLocation =
+ const XMLCh* schemaLocation =
getElementAttValue(elem, SchemaSymbols::fgATT_SCHEMALOCATION);
if (XMLString::stringLen(schemaLocation) == 0) {
@@ -363,7 +366,7 @@
// ------------------------------------------------------------------
// Resolve schema location
- // ------------------------------------------------------------------
+ // ------------------------------------------------------------------
InputSource* srcToFill = resolveSchemaLocation(schemaLocation);
Janitor<InputSource> janSrc(srcToFill);
@@ -422,11 +425,11 @@
if (!root.isNull()) {
- const XMLCh* targetNSURIString =
+ const XMLCh* targetNSURIString =
getElementAttValue(root,SchemaSymbols::fgATT_TARGETNAMESPACE);
if (XMLString::stringLen(targetNSURIString) != 0
- && XMLString::compareString(targetNSURIString,
+ && XMLString::compareString(targetNSURIString,
fTargetNSURIString) != 0){
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::IncludeNamespaceDifference,
schemaLocation, targetNSURIString);
@@ -438,7 +441,7 @@
// --------------------------------------------------------
if (fSchemaInfoRoot == 0) {
- fSchemaInfoRoot =
+ fSchemaInfoRoot =
new SchemaInfo(fElementDefaultQualified,
fAttributeDefaultQualified,
fBlockDefault,
@@ -457,12 +460,12 @@
setCurrentSchemaURL(includeURL);
traverseSchemaHeader();
- // and now we'd better save this stuff!
- fCurrentSchemaInfo =
+ // and now we'd better save this stuff!
+ fCurrentSchemaInfo =
new SchemaInfo(fElementDefaultQualified,
- fAttributeDefaultQualified,
+ fAttributeDefaultQualified,
fBlockDefault,
- fFinalDefault,
+ fFinalDefault,
fCurrentScope,
fCurrentSchemaURL,
fSchemaRootElement,
@@ -505,7 +508,7 @@
// ------------------------------------------------------------------
// Get 'schemaLocation' attribute
// ------------------------------------------------------------------
- const XMLCh* schemaLocation =
+ const XMLCh* schemaLocation =
getElementAttValue(elem, SchemaSymbols::fgATT_SCHEMALOCATION);
if (XMLString::stringLen(schemaLocation) == 0) {
@@ -515,7 +518,7 @@
// ------------------------------------------------------------------
// Resolve schema location
- // ------------------------------------------------------------------
+ // ------------------------------------------------------------------
InputSource* srcToFill = resolveSchemaLocation(schemaLocation);
Janitor<InputSource> janSrc(srcToFill);
@@ -581,7 +584,7 @@
if (!root.isNull()) {
- const XMLCh* targetNSURIString =
+ const XMLCh* targetNSURIString =
getElementAttValue(root,SchemaSymbols::fgATT_TARGETNAMESPACE);
if (XMLString::compareString(targetNSURIString, nameSpace) != 0) {
@@ -610,14 +613,14 @@
/**
* Traverse the Choice, Sequence declaration
*
- * <choice-sequqnce
- * id = ID
+ * <choice-sequqnce
+ * id = ID
* maxOccurs = (nonNegativeInteger | unbounded) : 1
* minOccurs = nonNegativeInteger : 1
* Content: (annotation?, (element | group | choice | sequence | any)*)
* </choice-sequence>
*/
-ContentSpecNode*
+ContentSpecNode*
TraverseSchema::traverseChoiceSequence(const DOM_Element& elem,
const int modelGroupType)
{
@@ -645,34 +648,34 @@
contentSpecNode = new ContentSpecNode(eltQName);
seeParticle = true;
- }
+ }
else if (childName.equals(SchemaSymbols::fgELT_GROUP)) {
contentSpecNode = 0/*traverseGroupDecl(child)*/;
- if (contentSpecNode == 0)
+ if (contentSpecNode == 0)
continue;
seeParticle = true;
- }
+ }
else if (childName.equals(SchemaSymbols::fgELT_CHOICE)) {
- contentSpecNode =
+ contentSpecNode =
traverseChoiceSequence(child,ContentSpecNode::Choice);
seeParticle = true;
- }
+ }
else if (childName.equals(SchemaSymbols::fgELT_SEQUENCE)) {
contentSpecNode =
traverseChoiceSequence(child,ContentSpecNode::Sequence);
seeParticle = true;
- }
+ }
else if (childName.equals(SchemaSymbols::fgELT_ANY)) {
contentSpecNode = traverseAny(child);
seeParticle = true;
- }
+ }
else {
- fBuffer.set(childName.rawBuffer(), childName.length());
+ fBuffer.set(childName.rawBuffer(), childName.length());
reportSchemaError(XMLUni::fgValidityDomain, XMLValid::GroupContentRestricted,
fBuffer.getRawBuffer());
}
@@ -705,14 +708,14 @@
/**
* Traverse SimpleType declaration:
* <simpleType
- * id = ID
+ * id = ID
* name = NCName>
* Content: (annotation? , ((list | restriction | union)))
* </simpleType>
*
* traverse <list>|<restriction>|<union>
*/
-int TraverseSchema::traverseSimpleTypeDecl(const DOM_Element& childElem)
+int TraverseSchema::traverseSimpleTypeDecl(const DOM_Element& childElem)
{
const XMLCh* name = getElementAttValue(childElem,SchemaSymbols::fgATT_NAME);
@@ -778,7 +781,7 @@
/**
* Traverse ComplexType Declaration - CR Implementation.
- *
+ *
* <complexType
* abstract = boolean
* block = #all or (possibly empty) subset of {extension, restriction}
@@ -807,7 +810,7 @@
name = genAnonTypeName(fgAnonCNamePrefix, fComplexTypeAnonCount);
}
-
+
if (!XMLString::isValidNCName(name)) {
//REVISIT - Should we return or continue and save type with wrong name?
@@ -842,7 +845,7 @@
// ------------------------------------------------------------------
// First, handle any ANNOTATION declaration and get next child
// ------------------------------------------------------------------
- DOM_Element child = checkContent(elem, XUtil::getFirstChildElement(elem),
+ DOM_Element child = checkContent(elem, XUtil::getFirstChildElement(elem),
true);
// ------------------------------------------------------------------
@@ -860,7 +863,7 @@
// ------------------------------------------------------------------
try {
if (child == 0) {
- // EMPTY complexType with complexContent
+ // EMPTY complexType with complexContent
processComplexContent(name, child, typeInfo, 0,0,0, false);
}
else {
@@ -919,13 +922,13 @@
typeInfo->setFinalSet(finalSet);
typeInfo->setScopeDefined(scopeDefined);
- if (XMLString::stringLen(lBlock) != 0
+ if (XMLString::stringLen(lBlock) != 0
&& XMLString::compareString(lBlock,SchemaSymbols::fgATTVAL_POUNDALL) != 0
&& ((blockSet & finalBlockValid) == 0)) {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::InvalidComplexTypeBlockValue, lBlock);
}
- if (XMLString::stringLen(lFinal) != 0
+ if (XMLString::stringLen(lFinal) != 0
&& XMLString::compareString(lFinal,SchemaSymbols::fgATTVAL_POUNDALL) != 0
&& ((finalSet & finalBlockValid) == 0)) {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::InvalidComplexTypeFinalValue, lFinal);
@@ -958,8 +961,8 @@
/**
* Traverse Any declaration
*
- * <any
- * id = ID
+ * <any
+ * id = ID
* maxOccurs = (nonNegativeInteger | unbounded) : 1
* minOccurs = nonNegativeInteger : 1
* namespace = ((##any | ##other) | List of (anyURI |
@@ -1021,10 +1024,10 @@
// ------------------------------------------------------------------
int emptyURI = fURIStringPool->addOrFind(XMLUni::fgZeroLenString);
ContentSpecNode* retSpecNode = 0;
- QName elemName(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString,
+ QName elemName(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString,
fTargetNSURI);
- if (XMLString::stringLen(nameSpace) == 0
+ if (XMLString::stringLen(nameSpace) == 0
|| XMLString::compareString(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDANY) == 0) {
retSpecNode = new ContentSpecNode(&elemName);
@@ -1076,7 +1079,7 @@
}
retSpecNode = secondNode;
- delete nameSpaceTokens;
+ delete nameSpaceTokens;
}
return retSpecNode;
@@ -1086,8 +1089,8 @@
/**
* Traverse all
*
- * <all
- * id = ID
+ * <all
+ * id = ID
* maxOccurs = 1 : 1
* minOccurs = (0 | 1) : 1
* {any attributes with non-schema namespace . . .}>
@@ -1126,9 +1129,9 @@
contentSpecNode = new ContentSpecNode(eltQName);
seeParticle = true;
- }
+ }
else {
- fBuffer.set(childName.rawBuffer(), childName.length());
+ fBuffer.set(childName.rawBuffer(), childName.length());
reportSchemaError(0, 0, fBuffer.getRawBuffer()); //Content of all group is restricted to elements only. '{0}' encountered and ignored."
}
@@ -1164,23 +1167,23 @@
/**
* Traverses Schema attribute declaration.
- *
- * <attribute
+ *
+ * <attribute
* fixed = string
* default = string
- * form = qualified | unqualified
- * id = ID
- * name = NCName
- * ref = QName
- * type = QName
+ * form = qualified | unqualified
+ * id = ID
+ * name = NCName
+ * ref = QName
+ * type = QName
* use = optional | prohibited | required : optional
>
* Content: (annotation? , simpleType?)
* <attribute/>
- *
+ *
* @param elem: the declaration of the attribute under consideration
*
- * @param typeInfo: Contains the complex type info of the element to which
+ * @param typeInfo: Contains the complex type info of the element to which
* the attribute declaration is attached.
*
*/
@@ -1214,7 +1217,7 @@
if (nameEmpty && refEmpty) {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefAttribute);
return;
- }
+ }
if(XMLString::stringLen(defaultVal) != 0) {
@@ -1244,7 +1247,7 @@
}
// processing 'name'
- if (!XMLString::isValidNCName(name)
+ if (!XMLString::isValidNCName(name)
|| XMLString::compareString(name, XMLUni::fgXMLNSString) == 0) {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::InvalidAttributeName, name);
@@ -1291,7 +1294,7 @@
fBuffer.getRawBuffer()) == 0) {
break;
}
-
+
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::InvalidAttributeContent, fBuffer.getRawBuffer());
simpleType = XUtil::getNextSiblingElement(simpleType);
}
@@ -1336,7 +1339,7 @@
}
else if (XMLString::compareString(localPart,XMLUni::fgIDRefsString) == 0) {
attType = XMLAttDef::IDRefs;
- }
+ }
else if (XMLString::compareString(localPart,XMLUni::fgEntityString) == 0) {
attType = XMLAttDef::Entity;
}
@@ -1358,7 +1361,7 @@
if (dv == 0 && XMLString::stringLen(typeURI) == 0) {
- DOM_Element topLevelType =
+ DOM_Element topLevelType =
getTopLevelComponentByName(SchemaSymbols::fgELT_SIMPLETYPE, localPart);
if (topLevelType != 0) {
@@ -1381,7 +1384,7 @@
if (dv == 0
&& XMLString::compareString(typeURI, fTargetNSURIString) == 0) {
- DOM_Element topLevelType =
+ DOM_Element topLevelType =
getTopLevelComponentByName(SchemaSymbols::fgELT_SIMPLETYPE,
localPart);
@@ -1405,11 +1408,11 @@
if (XMLString::stringLen(useVal) != 0) {
- if (XMLString::compareString(useVal,
+ if (XMLString::compareString(useVal,
SchemaSymbols::fgATTVAL_REQUIRED) == 0) {
required = true;
}
- else if (XMLString::compareString(useVal,
+ else if (XMLString::compareString(useVal,
SchemaSymbols::fgATTVAL_PROHIBITED) == 0) {
prohibited = true;
}
@@ -1431,8 +1434,8 @@
}
}
- // create SchemaAttDef
- SchemaAttDef* attDef =
+ // create SchemaAttDef
+ SchemaAttDef* attDef =
new SchemaAttDef(XMLUni::fgZeroLenString, name, uriIndex, attType);
attDef->setDatatypeValidator(dv);
@@ -1474,23 +1477,23 @@
/**
* Traverses Schema element declaration.
- *
- * <element
+ *
+ * <element
* abstract = boolean : false
* block = (#all | List of (substitution | extension | restriction
- * | list | union))
- * default = string
- * final = (#all | List of (extension | restriction))
- * fixed = string
+ * | list | union))
+ * default = string
+ * final = (#all | List of (extension | restriction))
+ * fixed = string
* form = (qualified | unqualified)
- * id = ID
+ * id = ID
* maxOccurs = (nonNegativeInteger | unbounded) : 1
* minOccurs = nonNegativeInteger : 1
- * name = NCName
+ * name = NCName
* nillable = boolean : false
- * ref = QName
- * substitutionGroup = QName
- * type = QName
+ * ref = QName
+ * substitutionGroup = QName
+ * type = QName
* Content: (annotation?, ((simpleType | complexType)?, (unique | key | keyref)*))
* </element>
*
@@ -1617,7 +1620,7 @@
noErrorFound = false;
}
- contentSpecType = SchemaElementDecl::Simple;
+ contentSpecType = SchemaElementDecl::Simple;
anonymousType = true;
content = XUtil::getNextSiblingElement(content);
}
@@ -1636,7 +1639,7 @@
const XMLCh* typeStr = getElementAttValue(elem, SchemaSymbols::fgATT_TYPE);
if (XMLString::stringLen(typeStr) > 0) {
- if (anonymousType) {
+ if (anonymousType) {
noErrorFound = false;
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::ElementWithTypeAndAnonType, name);
@@ -1658,12 +1661,12 @@
}
// Handle the substitutionGroup
- const XMLCh* subsGroupName =
+ const XMLCh* subsGroupName =
getElementAttValue(elem, SchemaSymbols::fgATT_SUBSTITUTIONGROUP);
if (XMLString::stringLen(subsGroupName) != 0) {
- SchemaElementDecl* subsElemDecl =
+ SchemaElementDecl* subsElemDecl =
getSubstituteGroupElemDecl(subsGroupName, noErrorFound);
if (subsElemDecl != 0) {
@@ -1696,7 +1699,7 @@
if (typeInfo == 0 && validator == 0) {
if (noErrorFound) { // ur type
- contentSpecType = SchemaElementDecl::Any;
+ contentSpecType = SchemaElementDecl::Any;
}
else {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::UntypedElement, name);
@@ -1722,7 +1725,7 @@
}
}
- // Now we can handle validation etc. of default and fixed attributes,
+ // Now we can handle validation etc. of default and fixed attributes,
// since we finally have all the type information.
if(XMLString::stringLen(fixed) != 0) {
deflt = fixed;
@@ -1742,13 +1745,13 @@
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::DatatypeValidationFailure, deflt);
}
- if(typeInfo != 0 &&
+ if(typeInfo != 0 &&
(typeInfo->getContentType() != SchemaElementDecl::Mixed &&
typeInfo->getContentType() != SchemaElementDecl::Simple)) {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::NotSimpleOrMixedElement, name);
}
}
-
+
// key/keyref/unique processing
// TO DO
@@ -1782,7 +1785,7 @@
const XMLCh* typeName = fStringPool.getValueForId(typeNameIndex);
const XMLCh* baseTypeName = getElementAttValue(content,
SchemaSymbols::fgATT_ITEMTYPE);
-
+
if (XUtil::getNextSiblingElement(content) != 0) {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::SimpleTypeContentError);
}
@@ -1831,7 +1834,7 @@
try {
- DatatypeValidator* newValidator =
+ DatatypeValidator* newValidator =
fDatatypeRegistry->getDatatypeValidator(qualifiedName);
if (newValidator == 0) {
@@ -1918,7 +1921,7 @@
facets = new RefHashTableOf<KVStringPair>(29, true);
}
- if (XMLString::compareString(facetStr,
+ if (XMLString::compareString(facetStr,
SchemaSymbols::fgELT_ENUMERATION) == 0) {
// REVISIT
@@ -1934,7 +1937,7 @@
if (isFirstPattern) { // fBuffer.isEmpty() - overhead call
pattern.set(attValue.rawBuffer(), attValueLen);
}
- else { //datatypes: 5.2.4 pattern
+ else { //datatypes: 5.2.4 pattern
isFirstPattern = false;
pattern.append(chPipe);
@@ -1983,7 +1986,7 @@
try {
- DatatypeValidator* newValidator =
+ DatatypeValidator* newValidator =
fDatatypeRegistry->getDatatypeValidator(qualifiedName);
if (newValidator == 0) {
@@ -2012,12 +2015,12 @@
int size = 1;
DOM_Element content = contentElem;
- const XMLCh* const typeName =
+ const XMLCh* const typeName =
fStringPool.getValueForId(typeNameIndex);
const XMLCh* baseTypeName = getElementAttValue(content,
SchemaSymbols::fgATT_MEMBERTYPES);
DatatypeValidator* baseValidator = 0;
- RefVectorOf<DatatypeValidator>* validators =
+ RefVectorOf<DatatypeValidator>* validators =
new RefVectorOf<DatatypeValidator>(4, false);
Janitor<DVRefVector> janValidators(validators);
@@ -2101,7 +2104,7 @@
try {
- DatatypeValidator* newValidator =
+ DatatypeValidator* newValidator =
fDatatypeRegistry->getDatatypeValidator(qualifiedName);
if (newValidator == 0) {
@@ -2121,20 +2124,20 @@
return fStringPool.addOrFind(qualifiedName);
}
-
+
/**
- * Traverse SimpleContent Declaration
- *
- * <simpleContent
- * id = ID
+ * Traverse SimpleContent Declaration
+ *
+ * <simpleContent
+ * id = ID
* {any attributes with non-schema namespace...}>
*
- * Content: (annotation? , (restriction | extension))
+ * Content: (annotation? , (restriction | extension))
* </simpleContent>
*
* <restriction
* base = QNAME
- * id = ID
+ * id = ID
* {any attributes with non-schema namespace...}>
*
* Content: (annotation?, (simpleType?, (minExclusive | minInclusive
@@ -2145,7 +2148,7 @@
*
* <extension
* base = QNAME
- * id = ID
+ * id = ID
* {any attributes with non-schema namespace...}>
* Content: (annotation? , ((attribute | attributeGroup)* , anyAttribute?))
* </extension>
@@ -2160,7 +2163,7 @@
// -----------------------------------------------------------------------
typeInfo->setContentType(SchemaElementDecl::Simple);
- DOM_Element simpleContent =
+ DOM_Element simpleContent =
checkContent(contentDecl, XUtil::getFirstChildElement(contentDecl),false);
// If there are no children, return
@@ -2187,9 +2190,9 @@
}
// -----------------------------------------------------------------------
- // Handle the base type name
+ // Handle the base type name
// -----------------------------------------------------------------------
- const XMLCh* baseName =
+ const XMLCh* baseName =
getElementAttValue(simpleContent, SchemaSymbols::fgATT_BASE);
if (XMLString::stringLen(baseName) == 0) {
@@ -2203,8 +2206,8 @@
const XMLCh* uri = resolvePrefixToURI(prefix);
DatatypeValidator* baseValidator = getDatatypeValidator(uri, localPart);
- if (baseValidator != 0
- && ((baseValidator->getFinalSet()
+ if (baseValidator != 0
+ && ((baseValidator->getFinalSet()
& SchemaSymbols::EXTENSION) == typeInfo->getDerivedBy())) {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::DisallowedSimpleTypeExtension,
@@ -2227,9 +2230,9 @@
// Process the content of the derivation
// -----------------------------------------------------------------------
//Skip over any annotations in the restriction or extension elements
- DOM_Element content = checkContent(simpleContent,
+ DOM_Element content = checkContent(simpleContent,
XUtil::getFirstChildElement(simpleContent), true);
-
+
if (typeInfo->getDerivedBy() == SchemaSymbols::RESTRICTION) {
//Schema Spec: 5.11: Complex Type Definition Properties Correct: 2
@@ -2239,7 +2242,7 @@
throw;
}
else {
- typeInfo->setBaseDatatypeValidator(
+ typeInfo->setBaseDatatypeValidator(
typeInfo->getBaseComplexTypeInfo()->getDatatypeValidator());
}
@@ -2248,11 +2251,11 @@
// ---------------------------------------------------------------
// There may be a simple type definition in the restriction
// element. The data type validator will be based on it, if
- // specified
+ // specified
// ---------------------------------------------------------------
if (content.getLocalName().equals(SchemaSymbols::fgELT_SIMPLETYPE)) {
- int simpleTypeNameIndex = traverseSimpleTypeDecl(content);
+ int simpleTypeNameIndex = traverseSimpleTypeDecl(content);
if (simpleTypeNameIndex !=-1) {
@@ -2281,15 +2284,15 @@
fBuffer.set(content.getLocalName().rawBuffer(), content.getLocalName().length());
facetId = fStringPool.addOrFind(fBuffer.getRawBuffer());
facetName = fStringPool.getValueForId(facetId);
-
+
// if not a valid facet, break from the loop
if (!isValidFacet(SchemaSymbols::fgELT_SIMPLECONTENT, facetName)) {
break;
}
-
+
if (content.getNodeType() == DOM_Node::ELEMENT_NODE) {
- DOMString attValue =
+ DOMString attValue =
content.getAttribute(SchemaSymbols::fgATT_VALUE);
if (facets == 0) {
@@ -2298,7 +2301,7 @@
fBuffer.set(attValue.rawBuffer(), attValue.length());
- if (XMLString::compareString(facetName,
+ if (XMLString::compareString(facetName,
SchemaSymbols::fgELT_ENUMERATION) == 0) {
enumData.append(fBuffer.getRawBuffer());
@@ -2310,7 +2313,7 @@
if (isFirstPattern) { // fBuffer.isEmpty() - overhead call
pattern.set(fBuffer.getRawBuffer());
}
- else { //datatypes: 5.2.4 pattern
+ else { //datatypes: 5.2.4 pattern
isFirstPattern = false;
pattern.append(chPipe);
@@ -2329,7 +2332,7 @@
}
}
- content = XUtil::getNextSiblingElement(content);
+ content = XUtil::getNextSiblingElement(content);
}
if (facets != 0) {
@@ -2358,7 +2361,7 @@
);
}
- XMLCh* qualifiedName =
+ XMLCh* qualifiedName =
getQualifiedName(fStringPool.addOrFind(typeName));
try {
@@ -2369,7 +2372,7 @@
(
fDatatypeRegistry->createDatatypeValidator
(
- fStringPool.getValueForId(nameId),
+ fStringPool.getValueForId(nameId),
typeInfo->getBaseDatatypeValidator(),
facets, false, 0
)
@@ -2407,26 +2410,26 @@
processAttributes(content, baseName, localPart, uri, typeInfo);
}
- if (XUtil::getNextSiblingElement(simpleContent) != 0) {
+ if (XUtil::getNextSiblingElement(simpleContent) != 0) {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildInSimpleContent);
}
} // End of function traverseSimpleContentDecl
/**
- * Traverse complexContent Declaration
- *
- * <complexContent
- * id = ID
- * mixed = boolean
+ * Traverse complexContent Declaration
+ *
+ * <complexContent
+ * id = ID
+ * mixed = boolean
* {any attributes with non-schema namespace...}>
*
- * Content: (annotation? , (restriction | extension))
+ * Content: (annotation? , (restriction | extension))
* </complexContent>
*
* <restriction
* base = QNAME
- * id = ID
+ * id = ID
* {any attributes with non-schema namespace...}>
*
* Content: (annotation? , (group | all | choice | sequence)?,
@@ -2435,9 +2438,9 @@
*
* <extension
* base = QNAME
- * id = ID
+ * id = ID
* {any attributes with non-schema namespace...}>
- * Content: (annotation? , (group | all | choice | sequence)?,
+ * Content: (annotation? , (group | all | choice | sequence)?,
* ((attribute | attributeGroup)* , anyAttribute?))
* </extension>
*/
@@ -2450,7 +2453,7 @@
// Determine whether the content is mixed, or element-only
// Setting here overrides any setting on the complex type decl
// -----------------------------------------------------------------------
- const XMLCh* const mixed =
+ const XMLCh* const mixed =
getElementAttValue(contentDecl, SchemaSymbols::fgATT_MIXED);
bool mixedContent = isMixed;
@@ -2463,13 +2466,13 @@
}
// -----------------------------------------------------------------------
- // Since the type must have complex content, set the simple type validators
+ // Since the type must have complex content, set the simple type validators
// to null
// -----------------------------------------------------------------------
typeInfo->setDatatypeValidator(0);
typeInfo->setBaseDatatypeValidator(0);
- DOM_Element complexContent =
+ DOM_Element complexContent =
checkContent(contentDecl,XUtil::getFirstChildElement(contentDecl),false);
// If there are no children, return
@@ -2495,9 +2498,9 @@
}
// -----------------------------------------------------------------------
- // Handle the base type name
+ // Handle the base type name
// -----------------------------------------------------------------------
- const XMLCh* baseName =
+ const XMLCh* baseName =
getElementAttValue(contentDecl, SchemaSymbols::fgATT_BASE);
if (XMLString::stringLen(baseName) == 0) {
@@ -2511,14 +2514,14 @@
const XMLCh* uri = resolvePrefixToURI(prefix);
// -------------------------------------------------------------
- // check if the base is "anyType"
+ // check if the base is "anyType"
// -------------------------------------------------------------
if (!(XMLString::compareString(uri, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) == 0
&& XMLString::compareString(localPart, SchemaSymbols::fgATTVAL_ANYTYPE) == 0)) {
processBaseTypeInfo(baseName, localPart, uri, typeInfo);
-
- //Check that the base is a complex type
+
+ //Check that the base is a complex type
if (typeInfo->getBaseComplexTypeInfo() == 0) {
reportSchemaError(XMLUni::fgXMLErrDomain,
@@ -2544,8 +2547,8 @@
/**
- * <anyAttribute
- * id = ID
+ * <anyAttribute
+ * id = ID
* namespace = ##any | ##other | ##local | list of {uri, ##targetNamespace}>
* processContents = (lax | skip | strict) : strict
* Content: (annotation?)
@@ -2597,7 +2600,7 @@
fBuffer.reset();
- if (XMLString::stringLen(nameSpace) == 0
+ if (XMLString::stringLen(nameSpace) == 0
|| XMLString::compareString(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDANY) == 0) {
// Do nothing - defaulted already
}
@@ -2627,7 +2630,7 @@
fBuffer.append(separator);
}
- if (XMLString::compareString(token,
+ if (XMLString::compareString(token,
SchemaSymbols::fgATTVAL_TWOPOUNDTRAGETNAMESPACE) == 0) {
fBuffer.append(fTargetNSURIString);
}
@@ -2722,17 +2725,17 @@
if (name.equals(SchemaSymbols::fgELT_ANNOTATION)) {
traverseAnnotationDecl(child);
- }
+ }
else if (name.equals(SchemaSymbols::fgELT_INCLUDE)) {
- traverseInclude(child);
- }
+ traverseInclude(child);
+ }
else if (name.equals(SchemaSymbols::fgELT_IMPORT)) {
- traverseImport(child);
- }
+ traverseImport(child);
+ }
else if (name.equals(SchemaSymbols::fgELT_REDEFINE)) {
- }
+ }
else
break;
}
@@ -2748,12 +2751,14 @@
}
else if (name.equals(SchemaSymbols::fgELT_SIMPLETYPE)) {
traverseSimpleTypeDecl(child);
- }
+ }
else if (name.equals(SchemaSymbols::fgELT_COMPLEXTYPE)) {
traverseComplexTypeDecl(child);
}
- else if (name.equals(SchemaSymbols::fgELT_ELEMENT)) {
- traverseElementDecl(child);
+ else if (name.equals(SchemaSymbols::fgELT_ELEMENT)) {
+
+ QName* elmQName = traverseElementDecl(child);
+ Janitor<QName> janQName(elmQName);
}
else if (name.equals(SchemaSymbols::fgELT_ATTRIBUTEGROUP)) {
// traverseAttributeGroupDecl(child, 0, 0);
@@ -2763,7 +2768,7 @@
}
else if (name.equals(SchemaSymbols::fgELT_GROUP)) {
traverseGroupDecl(child);
- }
+ }
else if (name.equals(SchemaSymbols::fgELT_NOTATION)) {
traverseNotationDecl(child); //TO DO
} else {
@@ -2790,7 +2795,7 @@
if (content.getLocalName().equals(SchemaSymbols::fgELT_ANNOTATION)) {
- traverseAnnotationDecl(contentElem);
+ traverseAnnotationDecl(contentElem);
content = XUtil::getNextSiblingElement(content);
if (content == 0) { // must be followed by content
@@ -2819,7 +2824,7 @@
DatatypeValidator* dv = 0;
- if (XMLString::stringLen(uriStr) == 0
+ if (XMLString::stringLen(uriStr) == 0
|| XMLString::compareString(uriStr, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) == 0) {
dv = fDatatypeRegistry->getDatatypeValidator(localPartStr);
}
@@ -2853,10 +2858,10 @@
}
-DatatypeValidator*
+DatatypeValidator*
TraverseSchema::checkForSimpleTypeValidator(const DOM_Element& content) {
- int typeNameIndex = traverseSimpleTypeDecl(content);
+ int typeNameIndex = traverseSimpleTypeDecl(content);
DatatypeValidator* baseValidator = 0;
if (typeNameIndex != -1) {
@@ -2874,10 +2879,10 @@
return baseValidator;
}
-ComplexTypeInfo*
+ComplexTypeInfo*
TraverseSchema::checkForComplexTypeInfo(const DOM_Element& content) {
- int typeNameIndex = traverseComplexTypeDecl(content);
+ int typeNameIndex = traverseComplexTypeDecl(content);
ComplexTypeInfo* baseTypeInfo = 0;
if (typeNameIndex != -1) {
@@ -2906,12 +2911,12 @@
if (baseValidator == 0) {
- DOM_Element baseTypeNode =
+ DOM_Element baseTypeNode =
getTopLevelComponentByName(SchemaSymbols::fgELT_SIMPLETYPE, localPart);
if (baseTypeNode != 0) {
- traverseSimpleTypeDecl(baseTypeNode);
+ traverseSimpleTypeDecl(baseTypeNode);
baseValidator = getDatatypeValidator(uri, localPart);
}
}
@@ -2935,7 +2940,7 @@
}
-DOM_Element
+DOM_Element
TraverseSchema::getTopLevelComponentByName(const XMLCh* const compCategory,
const XMLCh* const name) {
@@ -2972,9 +2977,9 @@
return XMLUni::fgZeroLenString;
}
- // REVISIT, !!!! a hack: needs to be updated later, cause now we only use
+ // REVISIT, !!!! a hack: needs to be updated later, cause now we only use
// localpart to key build-in datatype.
- if (XMLString::stringLen(prefix) == 0 &&
+ if (XMLString::stringLen(prefix) == 0 &&
XMLString::compareString(uriStr, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) == 0
&& XMLString::stringLen(fTargetNSURIString) == 0) {
@@ -2988,7 +2993,7 @@
bool TraverseSchema::isTopLevelComponent(const DOM_Element& elem) {
DOMString parentName = elem.getParentNode().getLocalName();
-
+
fBuffer.set(parentName.rawBuffer(), parentName.length());
XMLCh* nameStr = fBuffer.getRawBuffer();
@@ -3020,14 +3025,14 @@
}
unsigned int elemIndex = fSchemaGrammar->getElemId(eltName->getURI(),
- localPart, 0,
+ localPart, 0,
Grammar::TOP_LEVEL_SCOPE);
//if not found, traverse the top level element that if referenced
if (elemIndex == XMLElementDecl::fgInvalidElemId) {
- DOM_Element targetElem =
- getTopLevelComponentByName(SchemaSymbols::fgELT_ELEMENT,
+ DOM_Element targetElem =
+ getTopLevelComponentByName(SchemaSymbols::fgELT_ELEMENT,
localPart);
if (targetElem == 0) {
@@ -3036,7 +3041,7 @@
// REVISIT do we return 0 or what? for now we will return QName created
return eltName;
}
- }
+ }
return eltName;
}
@@ -3048,7 +3053,7 @@
}
if (XMLString::compareString(blockStr, SchemaSymbols::fgATTVAL_POUNDALL) == 0) {
- return SchemaSymbols::EXTENSION + SchemaSymbols::LIST +
+ return SchemaSymbols::EXTENSION + SchemaSymbols::LIST +
SchemaSymbols::RESTRICTION + SchemaSymbols::UNION +
SchemaSymbols::SUBSTITUTION;
}
@@ -3073,7 +3078,7 @@
if ((blockSet & SchemaSymbols::UNION) == 0) {
blockSet += SchemaSymbols::UNION;
- }
+ }
else {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::UnionRepeated);
}
@@ -3120,7 +3125,7 @@
}
if (XMLString::compareString(finalStr, SchemaSymbols::fgATTVAL_POUNDALL) == 0) {
- return SchemaSymbols::EXTENSION + SchemaSymbols::LIST +
+ return SchemaSymbols::EXTENSION + SchemaSymbols::LIST +
SchemaSymbols::RESTRICTION + SchemaSymbols::UNION;
}
@@ -3135,7 +3140,7 @@
if ((finalSet & SchemaSymbols::UNION) == 0) {
finalSet += SchemaSymbols::UNION;
- }
+ }
else {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::UnionRepeated);
}
@@ -3207,7 +3212,7 @@
|| XMLString::compareString(name, SchemaSymbols::fgELT_UNIQUE) == 0);
}
-const XMLCh*
+const XMLCh*
TraverseSchema::checkTypeFromAnotherSchema(const XMLCh* const typeStr) {
const XMLCh* prefix = getPrefix(typeStr);
@@ -3223,7 +3228,7 @@
return 0;
}
-DatatypeValidator*
+DatatypeValidator*
TraverseSchema::getElementTypeValidator(const XMLCh* const typeStr,
bool& noErrorDetected,
const XMLCh* const otherSchemaURI,
@@ -3244,9 +3249,9 @@
if (dv == 0) {
- if (XMLString::compareString(typeURI,
+ if (XMLString::compareString(typeURI,
SchemaSymbols::fgURI_SCHEMAFORSCHEMA) != 0
- || XMLString::compareString(fTargetNSURIString,
+ || XMLString::compareString(fTargetNSURIString,
SchemaSymbols::fgURI_SCHEMAFORSCHEMA) == 0) {
DOM_Element elem = getTopLevelComponentByName(
@@ -3268,7 +3273,7 @@
}
-ComplexTypeInfo*
+ComplexTypeInfo*
TraverseSchema::getElementComplexTypeInfo(const XMLCh* const typeStr,
bool& noErrorDetected,
const XMLCh* const otherSchemaURI)
@@ -3292,7 +3297,7 @@
if (typeInfo == 0) {
- if (XMLString::compareString(typeURI,
+ if (XMLString::compareString(typeURI,
SchemaSymbols::fgURI_SCHEMAFORSCHEMA) != 0
|| XMLString::compareString(fTargetNSURIString,
SchemaSymbols::fgURI_SCHEMAFORSCHEMA) == 0) {
@@ -3314,7 +3319,7 @@
}
-SchemaElementDecl*
+SchemaElementDecl*
TraverseSchema::getSubstituteGroupElemDecl(const XMLCh* const name,
bool& noErrorDetected) {
@@ -3332,7 +3337,7 @@
if (elemDecl == 0) {
- DOM_Element subsGroupElem =
+ DOM_Element subsGroupElem =
getTopLevelComponentByName(SchemaSymbols::fgELT_ELEMENT,
localPart);
@@ -3350,7 +3355,7 @@
}
}
- if (elemDecl == 0
+ if (elemDecl == 0
|| (elemDecl->getDatatypeValidator() == 0
&& elemDecl->getComplexTypeInfo() == 0)) {
@@ -3361,7 +3366,7 @@
return elemDecl;
}
-SchemaElementDecl*
+SchemaElementDecl*
TraverseSchema::getElementDeclFromNS(const XMLCh* const nameUri,
const XMLCh* const localPart) {
@@ -3379,7 +3384,7 @@
return 0;
}
-bool
+bool
TraverseSchema::isSubstitutionGroupValid(const SchemaElementDecl* const subsElemDecl,
const ComplexTypeInfo* const typeInfo,
const DatatypeValidator* const validator,
@@ -3395,7 +3400,7 @@
// an element with the given type-relation.
// Note: we assume that (complex|simple)Type processing checks
// whether the type in question allows itself to
- // be modified as this element desires.
+ // be modified as this element desires.
// Check for type relationship;
// that is, make sure that the type we're deriving has some relatoinship
@@ -3428,7 +3433,7 @@
ComplexTypeInfo* subsTypeInfo = subsElemDecl->getComplexTypeInfo();
const ComplexTypeInfo* elemTypeInfo = typeInfo;
-
+
for (; elemTypeInfo != subsTypeInfo;
elemTypeInfo = elemTypeInfo->getBaseComplexTypeInfo()) {
}
@@ -3474,7 +3479,7 @@
}
-SchemaElementDecl*
+SchemaElementDecl*
TraverseSchema::createSchemaElementDecl(const DOM_Element& elem,
const bool topLevel,
const unsigned short elemType)
@@ -3514,13 +3519,13 @@
int finalValid = SchemaSymbols::RESTRICTION + SchemaSymbols::EXTENSION;
int blockValid = finalValid + SchemaSymbols::SUBSTITUTION;
- if (XMLString::stringLen(block) != 0
+ if (XMLString::stringLen(block) != 0
&& XMLString::compareString(block,SchemaSymbols::fgATTVAL_POUNDALL) != 0
&& ((blockSet & blockValid) == 0)) {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::InvalidElementBlockValue, block);
}
- if (XMLString::stringLen(final) != 0
+ if (XMLString::stringLen(final) != 0
&& XMLString::compareString(final,SchemaSymbols::fgATTVAL_POUNDALL) != 0
&& ((finalSet & finalValid) == 0)) {
reportSchemaError(XMLUni::fgXMLErrDomain, XMLErrs::InvalidElementFinalValue, final);
@@ -3550,7 +3555,7 @@
}
const XMLCh* prefix = getPrefix(name);
- SchemaElementDecl* elemDecl =
+ SchemaElementDecl* elemDecl =
new SchemaElementDecl(prefix, name, uriIndex,
(SchemaElementDecl::ModelTypes) elemType,
enclosingScope);
@@ -3607,7 +3612,7 @@
// the referred attribute declaration and traverse it.
if (fAttributeDeclRegistry->containsKey(localPart) == false) {
- DOM_Element referredAttribute =
+ DOM_Element referredAttribute =
getTopLevelComponentByName(SchemaSymbols::fgELT_ATTRIBUTE, localPart);
if (referredAttribute == 0) {
@@ -3628,12 +3633,12 @@
return;
}
- bool required = (XMLString::compareString(useAttr,
+ bool required = (XMLString::compareString(useAttr,
SchemaSymbols::fgATTVAL_REQUIRED) == 0);
- bool prohibited = (XMLString::compareString(useAttr,
+ bool prohibited = (XMLString::compareString(useAttr,
SchemaSymbols::fgATTVAL_PROHIBITED) == 0);
QName* attQName = refAttDef->getAttName();
- SchemaAttDef* attDef = new SchemaAttDef(attQName->getPrefix(),
+ SchemaAttDef* attDef = new SchemaAttDef(attQName->getPrefix(),
attQName->getLocalPart(),
attQName->getURI(),
refAttDef->getType());
@@ -3665,7 +3670,7 @@
unsigned int minOccurs = 0;
unsigned int maxOccurs = 0;
DOMString nOccurs = elem.getAttribute(SchemaSymbols::fgATT_MINOCCURS);
-
+
if (nOccurs.length() > 0) {
fBuffer.set(nOccurs.rawBuffer(), nOccurs.length());
@@ -3691,12 +3696,12 @@
fBuffer.reset();
}
- XMLCh* maxOccursStr = XMLString::replicate(fBuffer.getRawBuffer());
+ XMLCh* maxOccursStr = XMLString::replicate(fBuffer.getRawBuffer());
ArrayJanitor<XMLCh> janMaxOccur(maxOccursStr);
XMLString::trim(maxOccursStr);
-
- bool isMaxUnbounded =
+
+ bool isMaxUnbounded =
(XMLString::compareString(maxOccursStr, fgUnbounded) == 0);
if (XMLString::stringLen(maxOccursStr) == 0) {
@@ -3712,7 +3717,7 @@
ContentSpecNode* saveNode = specNode;
ContentSpecNode* retNode = specNode;
-
+
if (minOccurs == 1 && maxOccurs == 1) {
}
else if (minOccurs == 0 && maxOccurs == 1) {
@@ -3742,9 +3747,9 @@
if (minOccurs == 0) {
- ContentSpecNode* optional =
+ ContentSpecNode* optional =
new ContentSpecNode(ContentSpecNode::ZeroOrOne, saveNode, 0);
-
+
retNode = optional;
for (int i=0; i < (int)(maxOccurs-minOccurs-1); i++) {
@@ -3759,7 +3764,7 @@
retNode, saveNode, true, false);
}
- ContentSpecNode* optional =
+ ContentSpecNode* optional =
new ContentSpecNode(ContentSpecNode::ZeroOrOne, saveNode, 0, false);
for (int j=0; j < (int)(maxOccurs-minOccurs); j++) {
@@ -3796,7 +3801,7 @@
if (childName.equals(SchemaSymbols::fgELT_GROUP)) {
-// specNode = expandContentModel(traverseGroupDecl(childElem),
+// specNode = expandContentModel(traverseGroupDecl(childElem),
// childElem);
attrNode = XUtil::getNextSiblingElement(childElem);
}
@@ -3818,8 +3823,8 @@
specNode = expandContentModel(traverseAll(childElem), childElem);
attrNode = XUtil::getNextSiblingElement(childElem);
- //TO DO: REVISIT
- //check that minOccurs = 1 and maxOccurs = 1
+ //TO DO: REVISIT
+ //check that minOccurs = 1 and maxOccurs = 1
}
else if (isAttrOrAttrGroup(childElem)) {
// reset the contentType
@@ -3836,7 +3841,7 @@
if (isMixed) {
- // TODO - check to see if we MUST have an element. What if only attributes
+ // TODO - check to see if we MUST have an element. What if only attributes
// were specified??
// add #PCDATA leaf
@@ -3858,7 +3863,7 @@
typeInfo->setContentSpec(specNode);
// -----------------------------------------------------------------------
- // Merge in information from base, if it exists
+ // Merge in information from base, if it exists
// -----------------------------------------------------------------------
ComplexTypeInfo* baseTypeInfo = typeInfo->getBaseComplexTypeInfo();
if (baseTypeInfo != 0) {
@@ -3874,7 +3879,7 @@
baseLocalPart);
throw;
}
-
+
//REVISIT: !!!really hairy stuff to check the particle derivation OK in 5.10
}
else {
@@ -3895,7 +3900,7 @@
}
else if (baseSpecNode != 0) {
- typeInfo->setContentSpec(
+ typeInfo->setContentSpec(
new ContentSpecNode(ContentSpecNode::Sequence, baseSpecNode,
typeInfo->getContentSpec(), false,
typeInfo->getAdoptContentSpec()));
@@ -3907,7 +3912,7 @@
}
// -------------------------------------------------------------
- // Set the content type
+ // Set the content type
// -------------------------------------------------------------
if (isMixed) {
typeInfo->setContentType(SchemaElementDecl::Mixed);
@@ -3951,7 +3956,7 @@
DatatypeValidator* baseDTValidator = 0;
// -------------------------------------------------------------
- // check if the base type is from another schema
+ // check if the base type is from another schema
// -------------------------------------------------------------
if (isBaseFromAnotherSchema(uriStr)) {
@@ -3981,7 +3986,7 @@
// assume the base is a complexType and try to locate the base type first
baseComplexTypeInfo = fComplexTypeRegistry->get(fBuffer.getRawBuffer());
- // if not found, 2 possibilities:
+ // if not found, 2 possibilities:
// 1: ComplexType in question has not been compiled yet;
// 2: base is SimpleTYpe;
if (baseComplexTypeInfo == 0) {
@@ -4042,7 +4047,7 @@
fBuffer.append(chComma);
fBuffer.append(localPart);
- ComplexTypeInfo* typeInfo =
+ ComplexTypeInfo* typeInfo =
((SchemaGrammar*)grammar)->getComplexTypeRegistry()->get(fBuffer.getRawBuffer());
return typeInfo;
@@ -4085,11 +4090,11 @@
if (childName.equals(SchemaSymbols::fgELT_ATTRIBUTE)) {
traverseAttributeDecl(child, typeInfo);
- }
- else if (childName.equals(SchemaSymbols::fgELT_ATTRIBUTEGROUP)) {
+ }
+ else if (childName.equals(SchemaSymbols::fgELT_ATTRIBUTEGROUP)) {
// TO DO
}
- else if (childName.equals(SchemaSymbols::fgELT_ANYATTRIBUTE) ) {
+ else if (childName.equals(SchemaSymbols::fgELT_ANYATTRIBUTE) ) {
attWildCard = traverseAnyAttribute(child);
janAttWildCard.reset(attWildCard);
}
@@ -4120,7 +4125,7 @@
if (baseTypeInfo != 0 && baseTypeInfo->hasAttDefs()) {
- SchemaAttDefList& baseAttList = (SchemaAttDefList&)
+ SchemaAttDefList& baseAttList = (SchemaAttDefList&)
baseTypeInfo->getAttDefList();
while (baseAttList.hasMoreElements()) {
@@ -4129,7 +4134,7 @@
XMLAttDef::AttTypes attType = attDef.getType();
QName* attName = attDef.getAttName();
- if (attType == XMLAttDef::Any_Any
+ if (attType == XMLAttDef::Any_Any
|| attType == XMLAttDef::Any_List
|| attType == XMLAttDef::Any_Local
|| attType == XMLAttDef::Any_Other) {
@@ -4143,14 +4148,14 @@
}
// if found a duplicate, if it is derived by restriction,
- // then skip the one from the base type
+ // then skip the one from the base type
if (typeInfo->contains(attName->getLocalPart())) {
if (typeInfo->getDerivedBy() == SchemaSymbols::RESTRICTION) {
continue;
}
}
-
+
SchemaAttDef* newAttDef = new SchemaAttDef(attName->getPrefix(),
attName->getLocalPart(),
attName->getURI(),
@@ -4197,7 +4202,7 @@
const XMLCh* const uri,
ComplexTypeInfo* const typeInfo)
{
- SchemaGrammar* aGrammar = (SchemaGrammar*)
+ SchemaGrammar* aGrammar = (SchemaGrammar*)
fGrammarResolver->getGrammar(uri);
if (XMLString::stringLen(uri) == 0 || aGrammar == 0
@@ -4213,7 +4218,7 @@
return -1;
}
- SchemaAttDef* tempAtt = (SchemaAttDef*)
+ SchemaAttDef* tempAtt = (SchemaAttDef*)
aGrammar->getAttributeDeclRegistry()->get(name);
if (tempAtt == 0) {
@@ -4268,7 +4273,7 @@
if (fScanner && XMLString::compareString(msgDomain, XMLUni::fgXMLErrDomain) == 0) {
fScanner->emitError((XMLErrs::Codes) errorCode);
}
- else if (fValidator && fScanner->getDoValidation()
+ else if (fValidator && fScanner->getDoValidation()
&& XMLString::compareString(msgDomain, XMLUni::fgValidityDomain) == 0) {
fValidator->emitError((XMLValid::Codes) errorCode);
}
@@ -4284,14 +4289,14 @@
if (fScanner && XMLString::compareString(msgDomain, XMLUni::fgXMLErrDomain) == 0) {
fScanner->emitError((XMLErrs::Codes) errorCode,text1,text2,text3,text4);
}
- else if (fValidator && fScanner->getDoValidation()
+ else if (fValidator && fScanner->getDoValidation()
&& XMLString::compareString(msgDomain, XMLUni::fgValidityDomain) == 0) {
fValidator->emitError((XMLValid::Codes) errorCode,text1,text2,text3,text4);
}
}
InputSource* TraverseSchema::resolveSchemaLocation(const XMLCh* const loc) {
-
+
// ------------------------------------------------------------------
// Create an input source
// ------------------------------------------------------------------
1.4 +9 -14 xml-xerces/c/src/validators/schema/TraverseSchema.hpp
Index: TraverseSchema.hpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/validators/schema/TraverseSchema.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- TraverseSchema.hpp 2001/05/11 13:27:38 1.3
+++ TraverseSchema.hpp 2001/05/11 21:51:20 1.4
@@ -55,7 +55,7 @@
*/
/*
- * $Id: TraverseSchema.hpp,v 1.3 2001/05/11 13:27:38 tng Exp $
+ * $Id: TraverseSchema.hpp,v 1.4 2001/05/11 21:51:20 knoaman Exp $
*/
#if !defined(TRAVERSESCHEMA_HPP)
@@ -185,7 +185,7 @@
// -----------------------------------------------------------------------
void reportSchemaError(const XMLCh* const msgDomain, const int errorCode);
void reportSchemaError(const XMLCh* const msgDomain,
- const int errorCode,
+ const int errorCode,
const XMLCh* const text1,
const XMLCh* const text2 = 0,
const XMLCh* const text3 = 0,
@@ -200,7 +200,7 @@
void retrieveNamespaceMapping();
/**
- * Extract all top-level attribute, attributeGroup, and group Decls and
+ * Extract all top-level attribute, attributeGroup, and group Decls and
* put them in the 3 hash tables in the SchemaGrammar.
*/
void extractTopLevel3Components(const DOM_Element& rootElem);
@@ -215,13 +215,13 @@
* Parameters:
* rootElem - top element for a given type declaration
* contentElem - content must be annotation? or some other simple content
- * isEmpty: - true if (annotation?, smth_else), false if (annotation?)
+ * isEmpty: - true if (annotation?, smth_else), false if (annotation?)
*
* Check for Annotation if it is present, traverse it. If a sibling is
* found and it is not an annotation return it, otherwise return 0.
* Used by traverseSimpleTypeDecl.
*/
- DOM_Element checkContent(const DOM_Element& rootElem,
+ DOM_Element checkContent(const DOM_Element& rootElem,
const DOM_Element& contentElem,
const bool isEmpty);
@@ -390,12 +390,7 @@
const XMLCh* getElementAttValue(const DOM_Element& elem,
const XMLCh* const attName);
- /**
- * Checks whether an name is a valid NCName.
- */
- bool isValidNCName(const XMLCh* const name);
-
- ContentSpecNode* expandContentModel(ContentSpecNode* const specNode,
+ ContentSpecNode* expandContentModel(ContentSpecNode* const specNode,
const DOM_Element& elem);
/**
@@ -563,7 +558,7 @@
|| elem.getAttribute(SchemaSymbols::fgATT_BLOCK).length() != 0
|| elem.getAttribute(SchemaSymbols::fgATT_FINAL).length() != 0
|| elem.getAttribute(SchemaSymbols::fgATT_TYPE).length() != 0
- || elem.getAttribute(SchemaSymbols::fgATT_DEFAULT).length() != 0
+ || elem.getAttribute(SchemaSymbols::fgATT_DEFAULT).length() != 0
|| elem.getAttribute(SchemaSymbols::fgATT_FIXED).length() != 0
|| elem.getAttribute(SchemaSymbols::fgATT_SUBSTITUTIONGROUP).length() != 0);
}
@@ -579,7 +574,7 @@
fBuffer.set(attValue.rawBuffer(), attValue.length());
unsigned int elemId = fStringPool.addOrFind(fBuffer.getRawBuffer());
- return fStringPool.getValueForId(elemId);
+ return fStringPool.getValueForId(elemId);
}
return 0;
@@ -590,7 +585,7 @@
if (XMLString::compareString(baseURI,fTargetNSURIString) != 0
&& XMLString::compareString(baseURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA) != 0
&& XMLString::stringLen(baseURI) != 0) {
- //REVISIT, !!!! a hack: for schema that has no
+ //REVISIT, !!!! a hack: for schema that has no
//target namespace, e.g. personal-schema.xml
return true;
}
---------------------------------------------------------------------
To unsubscribe, e-mail: xerces-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: xerces-cvs-help@xml.apache.org