You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by bo...@apache.org on 2008/03/10 15:10:21 UTC
svn commit: r635560 [4/5] - in /xerces/c/trunk:
Projects/MacOS/Xcode/XercesLib/XercesLib.xcode/
Projects/Win32/BCB6/Xerces-all/XercesLib/
Projects/Win32/BCC.551/Xerces-all/XercesLib/
Projects/Win32/VC6/xerces-all/XercesLib/ Projects/Win32/VC7.1/xerces-...
Modified: xerces/c/trunk/src/xercesc/util/regx/RegularExpression.cpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/regx/RegularExpression.cpp?rev=635560&r1=635559&r2=635560&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/regx/RegularExpression.cpp (original)
+++ xerces/c/trunk/src/xercesc/util/regx/RegularExpression.cpp Mon Mar 10 07:10:09 2008
@@ -5,9 +5,9 @@
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -35,7 +35,6 @@
#include <xercesc/framework/XMLBuffer.hpp>
#include <xercesc/util/OutOfMemoryException.hpp>
#include <xercesc/util/XMLInitializer.hpp>
-#include <xercesc/util/XMLRegisterCleanup.hpp>
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/ValueStackOf.hpp>
@@ -57,17 +56,6 @@
const unsigned int RegularExpression::SPECIAL_COMMA = 1024;
RangeToken* RegularExpression::fWordRange = 0;
-
-static void
-localCleanup()
-{
- RegularExpression::staticCleanup();
-}
-
-static XMLRegisterCleanup WordRangeCleanup;
-
-
-
bool RegularExpression::matchIgnoreCase(const XMLInt32 ch1,
const XMLInt32 ch2)
{
@@ -120,7 +108,7 @@
// ---------------------------------------------------------------------------
// RegularExpression::Context: Constructors and Destructor
// ---------------------------------------------------------------------------
-RegularExpression::Context::Context(MemoryManager* const manager) :
+RegularExpression::Context::Context(MemoryManager* const manager) :
fAdoptMatch(false)
, fStart(0)
, fLimit(0)
@@ -212,7 +200,7 @@
fStringMaxLen = stringLen;
fStart = start;
fLimit = limit;
- fLength = fLimit - fStart;
+ fLength = fLimit - fStart;
if (fAdoptMatch)
delete fMatch;
fMatch = 0;
@@ -416,11 +404,11 @@
RegxParser* RegularExpression::getRegexParser(const int options, MemoryManager* const manager)
{
- // the following construct causes an error in an Intel 7.1 32 bit compiler for
+ // the following construct causes an error in an Intel 7.1 32 bit compiler for
// red hat linux 7.2
// (when an exception is thrown the wrong object is deleted)
//RegxParser* regxParser = isSet(fOptions, XMLSCHEMA_MODE)
- // ? new (fMemoryManager) ParserForXMLSchema(fMemoryManager)
+ // ? new (fMemoryManager) ParserForXMLSchema(fMemoryManager)
// : new (fMemoryManager) RegxParser(fMemoryManager);
if (isSet(options, XMLSCHEMA_MODE))
return new (manager) ParserForXMLSchema(manager);
@@ -429,7 +417,7 @@
}
void RegularExpression::setPattern(const XMLCh* const pattern,
- const XMLCh* const options)
+ const XMLCh* const options)
{
fTokenFactory = new (fMemoryManager) TokenFactory(fMemoryManager);
@@ -453,7 +441,7 @@
// RegularExpression: Matching methods
// ---------------------------------------------------------------------------
bool RegularExpression::matches(const char* const expression
- , MemoryManager* const manager)
+ , MemoryManager* const manager)
{
XMLCh* tmpBuf = XMLString::transcode(expression, manager);
ArrayJanitor<XMLCh> janBuf(tmpBuf, manager);
@@ -494,14 +482,14 @@
// ---------------------------------------------------------------------------
// RegularExpression: Matching methods - Wide char version
// ---------------------------------------------------------------------------
-bool RegularExpression::matches(const XMLCh* const expression, MemoryManager* const manager)
+bool RegularExpression::matches(const XMLCh* const expression, MemoryManager* const manager)
{
return matches(expression, 0, XMLString::stringLen(expression), 0, manager);
}
bool RegularExpression::matches(const XMLCh* const expression
, const XMLSize_t start, const XMLSize_t end
- , MemoryManager* const manager)
+ , MemoryManager* const manager)
{
return matches(expression, start, end, 0, manager);
}
@@ -515,9 +503,9 @@
bool RegularExpression::matches(const XMLCh* const expression, const XMLSize_t start
, const XMLSize_t end, Match* const pMatch
- , MemoryManager* const manager)
+ , MemoryManager* const manager)
{
-
+
Context context(manager);
XMLSize_t strLength = XMLString::stringLen(expression);
@@ -550,7 +538,7 @@
context.fMatch->setStartPos(0, (int)context.fStart);
context.fMatch->setEndPos(0, matchEnd);
- }
+ }
return true;
}
@@ -568,9 +556,9 @@
if (context.fMatch != 0) {
context.fMatch->setStartPos(0, ret);
context.fMatch->setEndPos(0, (int)(ret + strLength));
- }
+ }
return true;
- }
+ }
return false;
}
@@ -672,7 +660,7 @@
context.fMatch->setStartPos(0, (int)matchStart);
context.fMatch->setEndPos(0, matchEnd);
- }
+ }
return true;
}
return false;
@@ -681,7 +669,7 @@
// ---------------------------------------------------------------------------
// RegularExpression: Tokenize methods
// ---------------------------------------------------------------------------
-RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const char* const expression)
+RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const char* const expression)
{
XMLCh* tmpBuf = XMLString::transcode(expression, fMemoryManager);
@@ -690,7 +678,7 @@
}
RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const char* const expression,
- const XMLSize_t start, const XMLSize_t end)
+ const XMLSize_t start, const XMLSize_t end)
{
XMLCh* tmpBuf = XMLString::transcode(expression, fMemoryManager);
@@ -703,7 +691,7 @@
// ---------------------------------------------------------------------------
// RegularExpression: Tokenize methods - Wide char version
// ---------------------------------------------------------------------------
-RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const XMLCh* const expression)
+RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const XMLCh* const expression)
{
return tokenize(expression, 0, XMLString::stringLen(expression), 0);
}
@@ -714,19 +702,19 @@
return tokenize(expression, start, end, 0);
}
-RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const XMLCh* const expression,
+RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const XMLCh* const expression,
const XMLSize_t start, const XMLSize_t end,
RefVectorOf<Match> *subEx)
{
-
+
RefArrayVectorOf<XMLCh>* tokenStack = new (fMemoryManager) RefArrayVectorOf<XMLCh>(16, true, fMemoryManager);
Context context(fMemoryManager);
XMLSize_t strLength = XMLString::stringLen(expression);
-
+
context.reset(expression, strLength, start, end, fNoClosures);
-
+
Match* lMatch = 0;
bool adoptMatch = false;
@@ -738,17 +726,17 @@
if (context.fAdoptMatch)
delete context.fMatch;
-
+
context.fMatch = lMatch;
context.fAdoptMatch = adoptMatch;
XMLSize_t tokStart = start;
XMLSize_t matchStart = start;
- for (; matchStart <= end; matchStart++) {
+ for (; matchStart <= end; matchStart++) {
int iMatchEnd = match(&context, fOperations, matchStart, 1);
-
+
if (iMatchEnd != -1) {
XMLSize_t matchEnd=iMatchEnd;
@@ -761,28 +749,28 @@
subEx->addElement(context.fMatch);
lMatch = new (fMemoryManager) Match(*(context.fMatch));
adoptMatch = true;
-
+
context.fAdoptMatch = adoptMatch;
context.fMatch = lMatch;
}
XMLCh* token;
if (tokStart == matchStart){
-
+
if (tokStart == strLength){
tokStart--;
- break;
+ break;
}
token = (XMLCh*) fMemoryManager->allocate(sizeof(XMLCh));//new XMLCh[1];
token[0] = chNull;
// When you tokenize using zero string, will return each
- // token in the string. Since the zero string will also
- // match the start/end characters, resulting in empty
- // tokens, we ignore them and do not add them to the stack.
- if (!XMLString::equals(fPattern, &chNull))
- tokenStack->addElement(token);
+ // token in the string. Since the zero string will also
+ // match the start/end characters, resulting in empty
+ // tokens, we ignore them and do not add them to the stack.
+ if (!XMLString::equals(fPattern, &chNull))
+ tokenStack->addElement(token);
else
fMemoryManager->deallocate(token);//delete[] token;
@@ -793,31 +781,31 @@
);//new XMLCh[matchStart + 1 - tokStart];
XMLString::subString(token, expression, tokStart, matchStart, fMemoryManager);
tokenStack->addElement(token);
- }
+ }
tokStart = matchEnd;
//decrement matchStart as will increment it at the top of the loop
- if (matchStart < matchEnd - 1)
- matchStart = matchEnd - 1;
+ if (matchStart < matchEnd - 1)
+ matchStart = matchEnd - 1;
}
}
-
+
XMLCh* token;
-
+
if (matchStart == tokStart + 1){
token = (XMLCh*) fMemoryManager->allocate(sizeof(XMLCh));//new XMLCh[1];
token[0] = chNull;
-
+
} else {
token = (XMLCh*) fMemoryManager->allocate
(
(strLength + 1 - tokStart) * sizeof(XMLCh)
);//new XMLCh[strLength + 1 - tokStart];
XMLString::subString(token, expression, tokStart, strLength, fMemoryManager);
- }
+ }
- if (!XMLString::equals(fPattern, &chNull))
+ if (!XMLString::equals(fPattern, &chNull))
tokenStack->addElement(token);
else
fMemoryManager->deallocate(token);//delete[] token;
@@ -829,7 +817,7 @@
// -----------------------------------------------------------------------
// RegularExpression: Replace methods
// -----------------------------------------------------------------------
-XMLCh* RegularExpression::replace(const char* const matchString,
+XMLCh* RegularExpression::replace(const char* const matchString,
const char* const replaceString)
{
@@ -841,7 +829,7 @@
return replace(tmpBuf, tmpBuf2, 0, XMLString::stringLen(tmpBuf));
}
-XMLCh* RegularExpression::replace(const char* const matchString,
+XMLCh* RegularExpression::replace(const char* const matchString,
const char* const replaceString,
const XMLSize_t start, const XMLSize_t end)
{
@@ -850,7 +838,7 @@
ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager);
XMLCh* tmpBuf2 = XMLString::transcode(replaceString, fMemoryManager);
ArrayJanitor<XMLCh> janBuf2(tmpBuf2, fMemoryManager);
-
+
return replace(tmpBuf, tmpBuf2, start, end);
}
@@ -858,15 +846,15 @@
// ---------------------------------------------------------------------------
// RegularExpression: Replace methods - Wide char version
// ---------------------------------------------------------------------------
-XMLCh* RegularExpression::replace(const XMLCh* const matchString,
+XMLCh* RegularExpression::replace(const XMLCh* const matchString,
const XMLCh* const replaceString)
{
- return replace(matchString, replaceString, 0,
+ return replace(matchString, replaceString, 0,
XMLString::stringLen(matchString));
}
-XMLCh* RegularExpression::replace(const XMLCh* const matchString,
+XMLCh* RegularExpression::replace(const XMLCh* const matchString,
const XMLCh* const replaceString,
const XMLSize_t start, const XMLSize_t end)
{
@@ -875,7 +863,7 @@
if (matches(XMLUni::fgZeroLenString, fMemoryManager)){
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Regex_RepPatMatchesZeroString, fMemoryManager);
}
-
+
RefVectorOf<Match> *subEx = new (fMemoryManager) RefVectorOf<Match>(10, true, fMemoryManager);
Janitor<RefVectorOf<Match> > janSubEx(subEx);
@@ -883,9 +871,9 @@
//of the subExpression within each of the matches
RefArrayVectorOf<XMLCh>* tokenStack = tokenize(matchString, start, end, subEx);
Janitor<RefArrayVectorOf<XMLCh> > janTokStack(tokenStack);
-
+
XMLBuffer result(1023, fMemoryManager);
-
+
int numSubEx = 0;
if (subEx && subEx->size() > 0)
@@ -900,18 +888,18 @@
if (i != tokStackSize - 1) {
- //if there are subExpressions, then determine the string we want to
+ //if there are subExpressions, then determine the string we want to
//substitute in.
if (numSubEx != 0) {
fMemoryManager->deallocate((XMLCh*)curRepString);
- curRepString = subInExp(replaceString, matchString, subEx->elementAt(i));
+ curRepString = subInExp(replaceString, matchString, subEx->elementAt(i));
}
result.append(curRepString);
}
- }
+ }
fMemoryManager->deallocate((XMLCh*)curRepString);
- return XMLString::replicate(result.getRawBuffer(), fMemoryManager);
+ return XMLString::replicate(result.getRawBuffer(), fMemoryManager);
}
@@ -925,21 +913,21 @@
RegularExpression::staticInitialize(XMLPlatformUtils::fgMemoryManager);
}
-
+void
+XMLInitializer::terminateRegularExpression()
+{
+ RegularExpression::staticCleanup();
+}
void
-RegularExpression::staticInitialize(MemoryManager* memoryManager)
+RegularExpression::staticInitialize(MemoryManager* memoryManager)
{
fWordRange = TokenFactory::staticGetRange(fgUniIsWord, false);
if (fWordRange == 0)
ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::Regex_RangeTokenGetError, fgUniIsWord, memoryManager);
-
- WordRangeCleanup.registerCleanup(localCleanup);
}
-
-
// ---------------------------------------------------------------------------
// RegularExpression: Helpers methods
// ---------------------------------------------------------------------------
@@ -1058,7 +1046,7 @@
case Op::O_FINITE_CLOSURE:
{
XMLInt32 id = tmpOp->getData();
- // if id is not -1, it's a closure with a child token having a minumum length,
+ // if id is not -1, it's a closure with a child token having a minumum length,
// where id is the index of the fOffsets array where its status is stored
if (id >= 0) {
int prevOffset = context->fOffsets[id];
@@ -1111,7 +1099,7 @@
case Op::O_CLOSURE:
{
XMLInt32 id = tmpOp->getData();
- // if id is not -1, it's a closure with a child token having a minumum length,
+ // if id is not -1, it's a closure with a child token having a minumum length,
// where id is the index of the fOffsets array where its status is stored
if (id >= 0) {
int prevOffset = context->fOffsets[id];
@@ -1139,7 +1127,7 @@
}
if (ret >= 0)
doReturn = ret;
- else
+ else
tmpOp = tmpOp->getNextOp();
}
}
@@ -1254,7 +1242,7 @@
tmpOp = tmpOp->getNextOp();
}
}
-
+
return (int)offset;
}
@@ -1271,7 +1259,7 @@
return false;
XMLInt32 strCh = 0;
-
+
if (!context->nextCh(strCh, tmpOffset, direction))
return false;
@@ -1297,7 +1285,7 @@
return false;
XMLInt32 strCh = 0;
-
+
if (!context->nextCh(strCh, tmpOffset, direction))
return false;
@@ -1327,7 +1315,7 @@
return false;
XMLInt32 strCh = 0;
-
+
if (!context->nextCh(strCh, tmpOffset, direction))
return false;
@@ -1522,7 +1510,7 @@
context->fMatch->setStartPos(index, save);
return ret;
}
-
+
context->fMatch->setEndPos(-index, (int)offset);
int ret = match(context, op->getNextOp(), offset, direction);
if (ret < 0)
@@ -1579,7 +1567,7 @@
XMLSize_t length = XMLString::stringLen(options);
for (XMLSize_t i=0; i < length; i++) {
-
+
int v = getOptionValue(options[i]);
if (v == 0)
@@ -1601,7 +1589,7 @@
}
Op* RegularExpression::compile(const Token* const token, Op* const next,
- const bool reverse)
+ const bool reverse)
{
Op* ret = 0;
@@ -1657,15 +1645,15 @@
/*
* Helper for Replace. This method prepares the replacement string by substituting
- * in actual values for parenthesized sub expressions.
+ * in actual values for parenthesized sub expressions.
*
* An error will be thrown if:
* 1) repString references an undefined subExpression
* 2) there is an unescaped chDollar which is not followed by a digit
*
*/
-const XMLCh* RegularExpression::subInExp(const XMLCh* const repString,
- const XMLCh* const origString,
+const XMLCh* RegularExpression::subInExp(const XMLCh* const repString,
+ const XMLCh* const origString,
const Match* subEx)
{
@@ -1673,12 +1661,12 @@
if (numSubExp == 0)
return XMLString::replicate(repString, fMemoryManager);
-
- bool notEscaped = true;
-
- XMLBuffer newString(1023, fMemoryManager);
-
- XMLCh indexStr[2]; //holds the string rep of a
+
+ bool notEscaped = true;
+
+ XMLBuffer newString(1023, fMemoryManager);
+
+ XMLCh indexStr[2]; //holds the string rep of a
indexStr[1] = chNull;
int index = -1;
@@ -1686,24 +1674,24 @@
for (const XMLCh* ptr = repString; *ptr != chNull; ptr++){
if ((*ptr == chDollarSign) && notEscaped) {
-
+
ptr++;
- //check that after the $ is a digit
+ //check that after the $ is a digit
if (!XMLString::isDigit(*ptr)){
-
+
//invalid replace string - $ must be followed by a digit
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Regex_InvalidRepPattern, fMemoryManager);
}
-
- indexStr[0] = *ptr; //get the digit
+
+ indexStr[0] = *ptr; //get the digit
index = XMLString::parseInt(indexStr, fMemoryManager); //convert it to an int
//now check that the index is legal
if (index > numSubExp){
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Regex_InvalidRepPattern, fMemoryManager);
}
-
+
int start = subEx->getStartPos(index);
int end = subEx->getEndPos(index);
@@ -1711,28 +1699,28 @@
for (int i=start; i<end; i++){
newString.append(origString[i]);
}
-
+
} else {
-
- //if you have a slash and then a character that's not a $ or /,
- //then it's an invalid replace string
+
+ //if you have a slash and then a character that's not a $ or /,
+ //then it's an invalid replace string
if (!notEscaped && (*ptr != chDollarSign && *ptr != chBackSlash)){
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Regex_InvalidRepPattern, fMemoryManager);
}
-
+
if (*ptr == chBackSlash){
notEscaped = false;
continue;
-
- }else
- notEscaped = true;
+
+ }else
+ notEscaped = true;
newString.append(*ptr);
}
}
return XMLString::replicate(newString.getRawBuffer(), fMemoryManager);
-
+
}
@@ -1778,7 +1766,7 @@
fFixedString = XMLString::replicate(fOperations->getLiteral(), fMemoryManager);
}
else{
-
+
XMLInt32 ch = fOperations->getData();
if ( ch >= 0x10000) { // add as constant
@@ -1798,7 +1786,7 @@
fBMPattern = new (fMemoryManager) BMPattern(fFixedString, 256,
isSet(fOptions, IGNORE_CASE), fMemoryManager);
}
- else if (!isSet(fOptions, XMLSCHEMA_MODE) &&
+ else if (!isSet(fOptions, XMLSCHEMA_MODE) &&
!isSet(fOptions, PROHIBIT_FIXED_STRING_OPTIMIZATION) &&
!isSet(fOptions, IGNORE_CASE)) {
@@ -1815,7 +1803,7 @@
fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
fFixedString = 0;
}
-
+
if (fFixedString != 0) {
fBMPattern = new (fMemoryManager) BMPattern(fFixedString, 256,
Modified: xerces/c/trunk/src/xercesc/util/regx/TokenFactory.cpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/regx/TokenFactory.cpp?rev=635560&r1=635559&r2=635560&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/regx/TokenFactory.cpp (original)
+++ xerces/c/trunk/src/xercesc/util/regx/TokenFactory.cpp Mon Mar 10 07:10:09 2008
@@ -30,7 +30,6 @@
#include <xercesc/util/regx/BlockRangeFactory.hpp>
#include <xercesc/util/regx/RangeTokenMap.hpp>
#include <xercesc/util/regx/RegxDefs.hpp>
-#include <xercesc/util/XMLRegisterCleanup.hpp>
XERCES_CPP_NAMESPACE_BEGIN
Modified: xerces/c/trunk/src/xercesc/validators/DTD/DTDGrammar.cpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/validators/DTD/DTDGrammar.cpp?rev=635560&r1=635559&r2=635560&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/validators/DTD/DTDGrammar.cpp (original)
+++ xerces/c/trunk/src/xercesc/validators/DTD/DTDGrammar.cpp Mon Mar 10 07:10:09 2008
@@ -5,9 +5,9 @@
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -25,7 +25,6 @@
// ---------------------------------------------------------------------------
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/XMLUni.hpp>
-#include <xercesc/util/XMLRegisterCleanup.hpp>
#include <xercesc/util/XMLInitializer.hpp>
#include <xercesc/validators/DTD/DTDGrammar.hpp>
#include <xercesc/validators/DTD/XMLDTDDescriptionImpl.hpp>
@@ -35,18 +34,11 @@
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
-// Local static data
-// ---------------------------------------------------------------------------
-static bool sEntityPoolMutexRegistered = false;
-static XMLMutex* sEntityPoolMutex = 0;
-static XMLRegisterCleanup entityPoolRegistryCleanup;
-
-// ---------------------------------------------------------------------------
// DTDGrammar: Static member data
// ---------------------------------------------------------------------------
NameIdPool<DTDEntityDecl>* DTDGrammar::fDefaultEntities = 0;
-void XMLInitializer::initializeDTDGrammarDfltEntities()
+void XMLInitializer::initializeDTDGrammar()
{
DTDGrammar::fDefaultEntities = new NameIdPool<DTDEntityDecl>(11, 12);
@@ -66,13 +58,15 @@
DTDGrammar::fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgGT, chCloseAngle, true, true));
DTDGrammar::fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgQuot, chDoubleQuote, true, true));
DTDGrammar::fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgApos, chSingleQuote, true, true));
-
- // register cleanup method
- entityPoolRegistryCleanup.registerCleanup(DTDGrammar::reinitDfltEntities);
- sEntityPoolMutexRegistered = true;
}
}
+void XMLInitializer::terminateDTDGrammar()
+{
+ delete DTDGrammar::fDefaultEntities;
+ DTDGrammar::fDefaultEntities = 0;
+}
+
//---------------------------------------------------------------------------
// DTDGrammar: Constructors and Destructor
// ---------------------------------------------------------------------------
@@ -82,7 +76,7 @@
, fElemNonDeclPool(0)
, fEntityDeclPool(0)
, fNotationDeclPool(0)
- , fGramDesc(0)
+ , fGramDesc(0)
, fValidated(false)
{
//
@@ -100,15 +94,12 @@
//REVISIT: use grammarPool to create
fGramDesc = new (fMemoryManager) XMLDTDDescriptionImpl(XMLUni::fgDTDEntityString, fMemoryManager);
-
- // Create default entities
- resetEntityDeclPool();
}
DTDGrammar::~DTDGrammar()
{
delete fElemDeclPool;
- if(fElemNonDeclPool)
+ if(fElemNonDeclPool)
{
delete fElemNonDeclPool;
}
@@ -118,20 +109,6 @@
}
// -----------------------------------------------------------------------
-// Notification that lazy data has been deleted
-// -----------------------------------------------------------------------
-void DTDGrammar::reinitDfltEntities() {
-
- delete fDefaultEntities;
- fDefaultEntities = 0;
-
- // delete local static data
- delete sEntityPoolMutex;
- sEntityPoolMutex = 0;
- sEntityPoolMutexRegistered = false;
-}
-
-// -----------------------------------------------------------------------
// Virtual methods
// -----------------------------------------------------------------------
XMLElementDecl* DTDGrammar::findOrAddElemDecl (const unsigned int uriId
@@ -186,7 +163,7 @@
if(!fElemNonDeclPool)
fElemNonDeclPool = new (fMemoryManager) NameIdPool<DTDElementDecl>(29, 128, fMemoryManager);
retVal->setId(fElemNonDeclPool->put(retVal));
- } else
+ } else
{
retVal->setId(fElemDeclPool->put(retVal));
}
@@ -207,54 +184,9 @@
fValidated = false;
}
-void DTDGrammar::resetEntityDeclPool() {
-
- // Initialize default entities if not initialized
- if (!sEntityPoolMutexRegistered)
- {
- if (!sEntityPoolMutex)
- {
- XMLMutexLock lock(XMLPlatformUtils::fgAtomicMutex);
- if (!sEntityPoolMutex)
- sEntityPoolMutex = new XMLMutex(XMLPlatformUtils::fgMemoryManager);
- }
-
- // Use a faux scope to synchronize while we do this
- {
- XMLMutexLock lock(sEntityPoolMutex);
-
- // If we got here first, then register it and set the registered flag
- if (!sEntityPoolMutexRegistered)
- {
- fDefaultEntities = new NameIdPool<DTDEntityDecl>(11, 12);
-
- //
- // Add the default entity entries for the character refs that must
- // always be present. We indicate that they are from the internal
- // subset. They aren't really, but they have to look that way so
- // that they are still valid for use within a standalone document.
- //
- // We also mark them as special char entities, which allows them
- // to be used in places whether other non-numeric general entities
- // cannot.
- //
- fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgAmp, chAmpersand, true, true));
- fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgLT, chOpenAngle, true, true));
- fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgGT, chCloseAngle, true, true));
- fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgQuot, chDoubleQuote, true, true));
- fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgApos, chSingleQuote, true, true));
-
- // register cleanup method
- entityPoolRegistryCleanup.registerCleanup(DTDGrammar::reinitDfltEntities);
- sEntityPoolMutexRegistered = true;
- }
- }
- }
-}
-
void DTDGrammar::setGrammarDescription( XMLGrammarDescription* gramDesc)
{
- if ((!gramDesc) ||
+ if ((!gramDesc) ||
(gramDesc->getGrammarType() != Grammar::DTDGrammarType))
return;
@@ -300,7 +232,7 @@
* which has been created in ctor
***/
fGramDesc->serialize(serEng);
-
+
serEng<<fValidated;
}
else
@@ -322,7 +254,7 @@
* which has been created in ctor
***/
fGramDesc->serialize(serEng);
-
+
serEng>>fValidated;
}
Modified: xerces/c/trunk/src/xercesc/validators/DTD/DTDGrammar.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/validators/DTD/DTDGrammar.hpp?rev=635560&r1=635559&r2=635560&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/validators/DTD/DTDGrammar.hpp (original)
+++ xerces/c/trunk/src/xercesc/validators/DTD/DTDGrammar.hpp Mon Mar 10 07:10:09 2008
@@ -5,9 +5,9 @@
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -144,7 +144,7 @@
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
-
+
const DTDEntityDecl* getEntityDecl(const XMLCh* const entName) const;
DTDEntityDecl* getEntityDecl(const XMLCh* const entName);
NameIdPool<DTDEntityDecl>* getEntityDeclPool();
@@ -165,12 +165,6 @@
// -----------------------------------------------------------------------
unsigned int putEntityDecl(DTDEntityDecl* const entityDecl) const;
-
- // -----------------------------------------------------------------------
- // Notification that lazy data has been deleted
- // -----------------------------------------------------------------------
- static void reinitDfltEntities();
-
/***
* Support for Serialization/De-serialization
***/
@@ -178,11 +172,6 @@
private:
// -----------------------------------------------------------------------
- // Private helper methods
- // -----------------------------------------------------------------------
- void resetEntityDeclPool();
-
- // -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
DTDGrammar(const DTDGrammar &);
@@ -224,7 +213,7 @@
NameIdPool<DTDEntityDecl>* fEntityDeclPool;
NameIdPool<XMLNotationDecl>* fNotationDeclPool;
XMLDTDDescription* fGramDesc;
-
+
bool fValidated;
friend class XMLInitializer;
@@ -359,7 +348,7 @@
inline unsigned int
DTDGrammar::putElemDecl(XMLElementDecl* const elemDecl,
- const bool notDeclared)
+ const bool notDeclared)
{
if (notDeclared)
{
Modified: xerces/c/trunk/src/xercesc/validators/common/GrammarResolver.cpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/validators/common/GrammarResolver.cpp?rev=635560&r1=635559&r2=635560&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/validators/common/GrammarResolver.cpp (original)
+++ xerces/c/trunk/src/xercesc/validators/common/GrammarResolver.cpp Mon Mar 10 07:10:09 2008
@@ -104,7 +104,6 @@
if (!fDataTypeReg) {
fDataTypeReg = new (fMemoryManager) DatatypeValidatorFactory(fMemoryManager);
- fDataTypeReg->expandRegistryToFullSchemaSet();
}
dv = fDataTypeReg->getDatatypeValidator(localPartStr);
Modified: xerces/c/trunk/src/xercesc/validators/datatype/DatatypeValidatorFactory.cpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/validators/datatype/DatatypeValidatorFactory.cpp?rev=635560&r1=635559&r2=635560&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/validators/datatype/DatatypeValidatorFactory.cpp (original)
+++ xerces/c/trunk/src/xercesc/validators/datatype/DatatypeValidatorFactory.cpp Mon Mar 10 07:10:09 2008
@@ -5,9 +5,9 @@
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -55,7 +55,6 @@
#include <xercesc/validators/datatype/YearMonthDatatypeValidator.hpp>
#include <xercesc/validators/datatype/DurationDatatypeValidator.hpp>
#include <xercesc/util/PlatformUtils.hpp>
-#include <xercesc/util/XMLRegisterCleanup.hpp>
#include <xercesc/util/XMLInitializer.hpp>
#include <xercesc/internal/XTemplateSerializer.hpp>
@@ -121,21 +120,33 @@
chLatin_P, chDigit_1, chLatin_M, chNull
};
-
-// ---------------------------------------------------------------------------
-// Local static data
-// ---------------------------------------------------------------------------
-static bool sBuiltInRegistryMutexRegistered = false;
-static XMLMutex* sBuiltInRegistryMutex = 0;
-static XMLRegisterCleanup builtInRegistryCleanup;
-
-
// ---------------------------------------------------------------------------
// DatatypeValidatorFactory: Static member data
// ---------------------------------------------------------------------------
RefHashTableOf<DatatypeValidator>* DatatypeValidatorFactory::fBuiltInRegistry = 0;
RefHashTableOf<XMLCanRepGroup>* DatatypeValidatorFactory::fCanRepRegistry = 0;
+void XMLInitializer::initializeDatatypeValidatorFactory()
+{
+ // @@ This is ugly. Need to make expandRegistryToFullSchemaSet
+ // static.
+ //
+ DatatypeValidatorFactory *dvFactory = new DatatypeValidatorFactory();
+ if (dvFactory) {
+ dvFactory->expandRegistryToFullSchemaSet();
+ delete dvFactory;
+ }
+}
+
+void XMLInitializer::terminateDatatypeValidatorFactory()
+{
+ delete DatatypeValidatorFactory::fBuiltInRegistry;
+ DatatypeValidatorFactory::fBuiltInRegistry = 0;
+
+ delete DatatypeValidatorFactory::fCanRepRegistry;
+ DatatypeValidatorFactory::fCanRepRegistry = 0;
+}
+
// ---------------------------------------------------------------------------
// DatatypeValidatorFactory: Constructors and Destructor
// ---------------------------------------------------------------------------
@@ -147,7 +158,7 @@
DatatypeValidatorFactory::~DatatypeValidatorFactory()
{
- cleanUp();
+ cleanUp();
}
@@ -159,34 +170,6 @@
if (fUserDefinedRegistry != 0) {
fUserDefinedRegistry->removeAll();
}
-
-}
-
-
-// -----------------------------------------------------------------------
-// Notification that lazy data has been deleted
-// -----------------------------------------------------------------------
-void DatatypeValidatorFactory::reinitRegistry() {
-
- delete fBuiltInRegistry;
- fBuiltInRegistry = 0;
-
- delete fCanRepRegistry;
- fCanRepRegistry = 0;
-
- // delete local static data
- delete sBuiltInRegistryMutex;
- sBuiltInRegistryMutex = 0;
- sBuiltInRegistryMutexRegistered = false;
-}
-
-void XMLInitializer::initializeDVFactory()
-{
- DatatypeValidatorFactory *dvFactory = new DatatypeValidatorFactory();
- if (dvFactory) {
- dvFactory->expandRegistryToFullSchemaSet();
- delete dvFactory;
- }
}
// ---------------------------------------------------------------------------
@@ -194,371 +177,349 @@
// ---------------------------------------------------------------------------
void DatatypeValidatorFactory::expandRegistryToFullSchemaSet()
{
- if (!sBuiltInRegistryMutexRegistered)
- {
- if (!sBuiltInRegistryMutex)
- {
- XMLMutexLock lock(XMLPlatformUtils::fgAtomicMutex);
- if (!sBuiltInRegistryMutex)
- sBuiltInRegistryMutex = new XMLMutex(XMLPlatformUtils::fgMemoryManager);
- }
-
- // Use a faux scope to synchronize while we do this
- {
- XMLMutexLock lock(sBuiltInRegistryMutex);
+ //Initialize common Schema/DTD Datatype validator set
+ fBuiltInRegistry = new RefHashTableOf<DatatypeValidator>(29);
- // If we got here first, then register it and set the registered flag
- if (!sBuiltInRegistryMutexRegistered)
- {
- //Initialize common Schema/DTD Datatype validator set
- fBuiltInRegistry = new RefHashTableOf<DatatypeValidator>(29);
+ DatatypeValidator *dv = new StringDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_STRING, dv);
- DatatypeValidator *dv = new StringDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_STRING, dv);
-
- dv = new NOTATIONDatatypeValidator();
- dv->setTypeName(XMLUni::fgNotationString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) XMLUni::fgNotationString, dv);
+ dv = new NOTATIONDatatypeValidator();
+ dv->setTypeName(XMLUni::fgNotationString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) XMLUni::fgNotationString, dv);
- dv = new AnySimpleTypeDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_ANYSIMPLETYPE, dv);
+ dv = new AnySimpleTypeDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_ANYSIMPLETYPE, dv);
- dv = new BooleanDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_BOOLEAN, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_BOOLEAN, dv);
+ dv = new BooleanDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_BOOLEAN, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_BOOLEAN, dv);
- dv = new DecimalDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DECIMAL, dv);
+ dv = new DecimalDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DECIMAL, dv);
- dv = new HexBinaryDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_HEXBINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_HEXBINARY, dv);
+ dv = new HexBinaryDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_HEXBINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_HEXBINARY, dv);
- dv = new Base64BinaryDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_BASE64BINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_BASE64BINARY, dv);
+ dv = new Base64BinaryDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_BASE64BINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_BASE64BINARY, dv);
- dv = new DoubleDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_DOUBLE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DOUBLE, dv);
+ dv = new DoubleDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_DOUBLE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DOUBLE, dv);
- dv = new FloatDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_FLOAT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_FLOAT, dv);
+ dv = new FloatDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_FLOAT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_FLOAT, dv);
- dv = new AnyURIDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_ANYURI, dv);
+ dv = new AnyURIDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_ANYURI, dv);
- dv = new QNameDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_QNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_QNAME, dv);
+ dv = new QNameDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_QNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_QNAME, dv);
- dv = new DateTimeDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_DATETIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DATETIME, dv);
+ dv = new DateTimeDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_DATETIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DATETIME, dv);
- dv = new DateDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_DATE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DATE, dv);
+ dv = new DateDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_DATE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DATE, dv);
- dv = new TimeDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_TIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_TIME, dv);
+ dv = new TimeDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_TIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_TIME, dv);
- dv = new DayDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_DAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DAY, dv);
+ dv = new DayDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_DAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DAY, dv);
- dv = new MonthDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_MONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_MONTH, dv);
+ dv = new MonthDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_MONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_MONTH, dv);
- dv = new MonthDayDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_MONTHDAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_MONTHDAY, dv);
+ dv = new MonthDayDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_MONTHDAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_MONTHDAY, dv);
- dv = new YearDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_YEAR, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_YEAR, dv);
+ dv = new YearDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_YEAR, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_YEAR, dv);
- dv = new YearMonthDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_YEARMONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_YEARMONTH, dv);
+ dv = new YearMonthDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_YEARMONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_YEARMONTH, dv);
- dv = new DurationDatatypeValidator();
- dv->setTypeName(SchemaSymbols::fgDT_DURATION, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DURATION, dv);
+ dv = new DurationDatatypeValidator();
+ dv->setTypeName(SchemaSymbols::fgDT_DURATION, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DURATION, dv);
- // REVISIT
- // We are creating a lot of Hashtables for the facets of the different
- // 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.
- RefHashTableOf<KVStringPair>* facets = new RefHashTableOf<KVStringPair>(3);
+ // REVISIT
+ // We are creating a lot of Hashtables for the facets of the different
+ // 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.
+ RefHashTableOf<KVStringPair>* facets = new RefHashTableOf<KVStringPair>(3);
- // Create 'normalizedString' datatype validator
- facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
- new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_REPLACE));
+ // Create 'normalizedString' datatype validator
+ facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
+ new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_REPLACE));
- createDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING,
- getDatatypeValidator(SchemaSymbols::fgDT_STRING),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING,
+ getDatatypeValidator(SchemaSymbols::fgDT_STRING),
+ facets, 0, false, 0, false);
- // Create 'token' datatype validator
- facets = new RefHashTableOf<KVStringPair>(3);
- facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
- new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
+ // Create 'token' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(3);
+ facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
+ new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
- createDatatypeValidator(SchemaSymbols::fgDT_TOKEN,
- getDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_TOKEN,
+ getDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING),
+ facets, 0, false, 0, false);
- dv = new NameDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_TOKEN), 0, 0, 0);
- dv->setTypeName(SchemaSymbols::fgDT_NAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_NAME, dv);
+ dv = new NameDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_TOKEN), 0, 0, 0);
+ dv->setTypeName(SchemaSymbols::fgDT_NAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_NAME, dv);
- dv = new NCNameDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NAME), 0, 0, 0);
- dv->setTypeName(SchemaSymbols::fgDT_NCNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_NCNAME, dv);
+ dv = new NCNameDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NAME), 0, 0, 0);
+ dv->setTypeName(SchemaSymbols::fgDT_NCNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_NCNAME, dv);
- // Create 'NMTOKEN' datatype validator
- facets = new RefHashTableOf<KVStringPair>(3);
+ // Create 'NMTOKEN' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(3);
- facets->put((void*) SchemaSymbols::fgELT_PATTERN ,
- new KVStringPair(SchemaSymbols::fgELT_PATTERN,fgTokPattern));
- facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
- new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
+ facets->put((void*) SchemaSymbols::fgELT_PATTERN ,
+ new KVStringPair(SchemaSymbols::fgELT_PATTERN,fgTokPattern));
+ facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
+ new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
- createDatatypeValidator(XMLUni::fgNmTokenString,
- getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),facets, 0, false, 0, false);
+ createDatatypeValidator(XMLUni::fgNmTokenString,
+ getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),facets, 0, false, 0, false);
- // Create 'NMTOKENS' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
- new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
+ // Create 'NMTOKENS' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
+ facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
+ new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
- createDatatypeValidator(XMLUni::fgNmTokensString,
- getDatatypeValidator(XMLUni::fgNmTokenString), facets, 0, true, 0, false);
+ createDatatypeValidator(XMLUni::fgNmTokensString,
+ getDatatypeValidator(XMLUni::fgNmTokenString), facets, 0, true, 0, false);
- // Create 'language' datatype validator
- facets = new RefHashTableOf<KVStringPair>(3);
+ // Create 'language' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(3);
- facets->put((void*) SchemaSymbols::fgELT_PATTERN,
- new KVStringPair(SchemaSymbols::fgELT_PATTERN, XMLUni::fgLangPattern));
+ facets->put((void*) SchemaSymbols::fgELT_PATTERN,
+ new KVStringPair(SchemaSymbols::fgELT_PATTERN, XMLUni::fgLangPattern));
- createDatatypeValidator(SchemaSymbols::fgDT_LANGUAGE,
- getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_LANGUAGE,
+ getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),
+ facets, 0, false, 0, false);
- // Create 'integer' datatype validator
- facets = new RefHashTableOf<KVStringPair>(3);
+ // Create 'integer' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(3);
- facets->put((void*) SchemaSymbols::fgELT_FRACTIONDIGITS,
- new KVStringPair(SchemaSymbols::fgELT_FRACTIONDIGITS, XMLUni::fgValueZero));
+ facets->put((void*) SchemaSymbols::fgELT_FRACTIONDIGITS,
+ new KVStringPair(SchemaSymbols::fgELT_FRACTIONDIGITS, XMLUni::fgValueZero));
- facets->put((void*) SchemaSymbols::fgELT_PATTERN,
- new KVStringPair(SchemaSymbols::fgELT_PATTERN, fgIntegerPattern));
+ facets->put((void*) SchemaSymbols::fgELT_PATTERN,
+ new KVStringPair(SchemaSymbols::fgELT_PATTERN, fgIntegerPattern));
- createDatatypeValidator(SchemaSymbols::fgDT_INTEGER,
- getDatatypeValidator(SchemaSymbols::fgDT_DECIMAL),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_INTEGER,
+ getDatatypeValidator(SchemaSymbols::fgDT_DECIMAL),
+ facets, 0, false, 0, false);
- // Create 'nonPositiveInteger' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'nonPositiveInteger' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgValueZero));
+ facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgValueZero));
- createDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER,
- getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER,
+ getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
+ facets, 0, false, 0, false);
- // Create 'negativeInteger' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'negativeInteger' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgNegOne));
+ facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgNegOne));
- createDatatypeValidator(SchemaSymbols::fgDT_NEGATIVEINTEGER,
- getDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_NEGATIVEINTEGER,
+ getDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER),
+ facets, 0, false, 0, false);
- // Create 'long' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'long' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgLongMaxInc));
- facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgLongMinInc));
+ facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgLongMaxInc));
+ facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgLongMinInc));
- createDatatypeValidator(SchemaSymbols::fgDT_LONG,
- getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_LONG,
+ getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
+ facets, 0, false, 0, false);
- // Create 'int' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'int' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgIntMaxInc));
- facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgIntMinInc));
+ facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgIntMaxInc));
+ facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgIntMinInc));
- createDatatypeValidator(SchemaSymbols::fgDT_INT,
- getDatatypeValidator(SchemaSymbols::fgDT_LONG),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_INT,
+ getDatatypeValidator(SchemaSymbols::fgDT_LONG),
+ facets, 0, false, 0, false);
- // Create 'short' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'short' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgShortMaxInc));
- facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgShortMinInc));
+ facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgShortMaxInc));
+ facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgShortMinInc));
- createDatatypeValidator(SchemaSymbols::fgDT_SHORT,
- getDatatypeValidator(SchemaSymbols::fgDT_INT),
- facets, 0, false, 0 ,false);
+ createDatatypeValidator(SchemaSymbols::fgDT_SHORT,
+ getDatatypeValidator(SchemaSymbols::fgDT_INT),
+ facets, 0, false, 0 ,false);
- // Create 'byte' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'byte' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgByteMaxInc));
- facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgByteMinInc));
+ facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgByteMaxInc));
+ facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgByteMinInc));
- createDatatypeValidator(SchemaSymbols::fgDT_BYTE,
- getDatatypeValidator(SchemaSymbols::fgDT_SHORT),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_BYTE,
+ getDatatypeValidator(SchemaSymbols::fgDT_SHORT),
+ facets, 0, false, 0, false);
- // Create 'nonNegativeInteger' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'nonNegativeInteger' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgValueZero));
+ facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgValueZero));
- createDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER,
- getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER,
+ getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
+ facets, 0, false, 0, false);
- // Create 'unsignedLong' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'unsignedLong' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgULongMaxInc));
+ facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgULongMaxInc));
- createDatatypeValidator(SchemaSymbols::fgDT_ULONG,
- getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_ULONG,
+ getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
+ facets, 0, false, 0, false);
- // Create 'unsignedInt' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'unsignedInt' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUIntMaxInc));
+ facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUIntMaxInc));
- createDatatypeValidator(SchemaSymbols::fgDT_UINT,
- getDatatypeValidator(SchemaSymbols::fgDT_ULONG),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_UINT,
+ getDatatypeValidator(SchemaSymbols::fgDT_ULONG),
+ facets, 0, false, 0, false);
- // Create 'unsignedShort' datatypeValidator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'unsignedShort' datatypeValidator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUShortMaxInc));
+ facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUShortMaxInc));
- createDatatypeValidator(SchemaSymbols::fgDT_USHORT,
- getDatatypeValidator(SchemaSymbols::fgDT_UINT),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_USHORT,
+ getDatatypeValidator(SchemaSymbols::fgDT_UINT),
+ facets, 0, false, 0, false);
- // Create 'unsignedByte' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'unsignedByte' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUByteMaxInc));
+ facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUByteMaxInc));
- createDatatypeValidator(SchemaSymbols::fgDT_UBYTE,
- getDatatypeValidator(SchemaSymbols::fgDT_USHORT),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_UBYTE,
+ getDatatypeValidator(SchemaSymbols::fgDT_USHORT),
+ facets, 0, false, 0, false);
- // Create 'positiveInteger' datatype validator
- facets = new RefHashTableOf<KVStringPair>(2);
+ // Create 'positiveInteger' datatype validator
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
- new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgValueOne));
+ facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
+ new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgValueOne));
- createDatatypeValidator(SchemaSymbols::fgDT_POSITIVEINTEGER,
- getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
- facets, 0, false, 0, false);
+ createDatatypeValidator(SchemaSymbols::fgDT_POSITIVEINTEGER,
+ getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
+ facets, 0, false, 0, false);
- // Create 'ID', 'IDREF' and 'ENTITY' datatype validator
- dv = new IDDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
- dv->setTypeName(XMLUni::fgIDString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) XMLUni::fgIDString, dv);
+ // Create 'ID', 'IDREF' and 'ENTITY' datatype validator
+ dv = new IDDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
+ dv->setTypeName(XMLUni::fgIDString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) XMLUni::fgIDString, dv);
- dv = new IDREFDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
- dv->setTypeName(XMLUni::fgIDRefString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) XMLUni::fgIDRefString, dv);
+ dv = new IDREFDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
+ dv->setTypeName(XMLUni::fgIDRefString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) XMLUni::fgIDRefString, dv);
- dv = new ENTITYDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
- dv->setTypeName(XMLUni::fgEntityString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- fBuiltInRegistry->put((void*) XMLUni::fgEntityString, dv);
+ dv = new ENTITYDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
+ dv->setTypeName(XMLUni::fgEntityString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
+ fBuiltInRegistry->put((void*) XMLUni::fgEntityString, dv);
- facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
- new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
+ facets = new RefHashTableOf<KVStringPair>(2);
+ facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
+ new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
- // Create 'IDREFS' datatype validator
- createDatatypeValidator
- (
- XMLUni::fgIDRefsString
- , getDatatypeValidator(XMLUni::fgIDRefString)
- , facets
- , 0
- , true
- , 0
- , false
- );
+ // Create 'IDREFS' datatype validator
+ createDatatypeValidator
+ (
+ XMLUni::fgIDRefsString
+ , getDatatypeValidator(XMLUni::fgIDRefString)
+ , facets
+ , 0
+ , true
+ , 0
+ , false
+ );
- facets = new RefHashTableOf<KVStringPair>(2);
+ facets = new RefHashTableOf<KVStringPair>(2);
- facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
- new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
+ facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
+ new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
- // Create 'ENTITIES' datatype validator
- createDatatypeValidator
- (
- XMLUni::fgEntitiesString
- , getDatatypeValidator(XMLUni::fgEntityString)
- , facets
- , 0
- , true
- , 0
- , false
- );
+ // Create 'ENTITIES' datatype validator
+ createDatatypeValidator
+ (
+ XMLUni::fgEntitiesString
+ , getDatatypeValidator(XMLUni::fgEntityString)
+ , facets
+ , 0
+ , true
+ , 0
+ , false
+ );
- initCanRepRegistory();
-
- // register cleanup method
- builtInRegistryCleanup.registerCleanup(DatatypeValidatorFactory::reinitRegistry);
- sBuiltInRegistryMutexRegistered = true;
- }
- }
- }
+ initCanRepRegistory();
}
+
/***
*
* For Decimal-derivated, an instance of DecimalDatatypeValidator
- * can be used by the primitive datatype, decimal, or any one of
+ * can be used by the primitive datatype, decimal, or any one of
* the derivated datatypes, such as int, long, unsighed short, just
* name a few, or any user-defined datatypes, which may derivate from
- * either the primitive datatype, decimal, or from any one of those
+ * either the primitive datatype, decimal, or from any one of those
* decimal derivated datatypes, or other user-defined datatypes, which
* in turn, indirectly derivate from decimal or decimal-derived.
*
@@ -599,7 +560,7 @@
fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_UINT),
new XMLCanRepGroup(XMLCanRepGroup::Decimal_Derivated_unsigned));
fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_USHORT),
- new XMLCanRepGroup(XMLCanRepGroup::Decimal_Derivated_unsigned));
+ new XMLCanRepGroup(XMLCanRepGroup::Decimal_Derivated_unsigned));
fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_UBYTE),
new XMLCanRepGroup(XMLCanRepGroup::Decimal_Derivated_unsigned));
@@ -686,7 +647,7 @@
datatypeValidator->setOrdered(XSSimpleTypeDefinition::ORDERED_FALSE);
datatypeValidator->setNumeric(false);
if (facets &&
- ((facets->get(SchemaSymbols::fgELT_LENGTH) ||
+ ((facets->get(SchemaSymbols::fgELT_LENGTH) ||
(facets->get(SchemaSymbols::fgELT_MINLENGTH) && facets->get(SchemaSymbols::fgELT_MAXLENGTH)))))
{
datatypeValidator->setBounded(true);
@@ -721,14 +682,14 @@
datatypeValidator->setOrdered(baseValidator->getOrdered());
datatypeValidator->setNumeric(baseValidator->getNumeric());
RefHashTableOf<KVStringPair>* baseFacets = baseValidator->getFacets();
- if (facets &&
- ((facets->get(SchemaSymbols::fgELT_MININCLUSIVE) ||
+ if (facets &&
+ ((facets->get(SchemaSymbols::fgELT_MININCLUSIVE) ||
facets->get(SchemaSymbols::fgELT_MINEXCLUSIVE) ||
- (baseFacets && (baseFacets->get(SchemaSymbols::fgELT_MININCLUSIVE) ||
+ (baseFacets && (baseFacets->get(SchemaSymbols::fgELT_MININCLUSIVE) ||
baseFacets->get(SchemaSymbols::fgELT_MINEXCLUSIVE))))) &&
- (facets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) ||
- facets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE) ||
- (baseFacets && ((baseFacets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) ||
+ (facets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) ||
+ facets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE) ||
+ (baseFacets && ((baseFacets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) ||
baseFacets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE))))))
{
datatypeValidator->setBounded(true);
@@ -754,7 +715,7 @@
//else if ((facets->get(SchemaSymbols::fgELT_MININCLUSIVE) || facets->get(SchemaSymbols::fgELT_MINEXCLUSIVE)) &&
// (facets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) || facets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE)))
else if (datatypeValidator->getBounded() ||
- datatypeValidator->getType() == DatatypeValidator::Date ||
+ datatypeValidator->getType() == DatatypeValidator::Date ||
datatypeValidator->getType() == DatatypeValidator::YearMonth ||
datatypeValidator->getType() == DatatypeValidator::Year ||
datatypeValidator->getType() == DatatypeValidator::MonthDay ||
@@ -765,15 +726,15 @@
{
datatypeValidator->setFinite(true);
}
- else
+ else
{
datatypeValidator->setFinite(false);
}
}
- else
+ else
{
datatypeValidator->setFinite(false);
- }
+ }
}
if (datatypeValidator != 0) {
@@ -798,8 +759,8 @@
static DatatypeValidator::ValidatorType getPrimitiveDV(DatatypeValidator::ValidatorType validationDV)
{
- if (validationDV == DatatypeValidator::ID ||
- validationDV == DatatypeValidator::IDREF ||
+ if (validationDV == DatatypeValidator::ID ||
+ validationDV == DatatypeValidator::IDREF ||
validationDV == DatatypeValidator::ENTITY)
{
return DatatypeValidator::String;
@@ -842,7 +803,7 @@
// Set PSVI information for Ordered, Numeric, Bounded & Finite
unsigned int valSize = validators->size();
- if (valSize)
+ if (valSize)
{
DatatypeValidator::ValidatorType ancestorId = getPrimitiveDV(validators->elementAt(0)->getType());
@@ -854,7 +815,7 @@
bool allNumeric = true;
bool allBounded = true;
bool allFinite = true;
-
+
for(unsigned int i = 0 ; (i < valSize) && (commonAnc || allOrderedFalse || allNumeric || allBounded || allFinite); i++)
{
// for the other member types, check whether the value is false
@@ -863,7 +824,7 @@
commonAnc = ancestorId == getPrimitiveDV(validators->elementAt(i)->getType());
if (allOrderedFalse)
allOrderedFalse = validators->elementAt(i)->getOrdered() == XSSimpleTypeDefinition::ORDERED_FALSE;
-
+
if (allNumeric && !validators->elementAt(i)->getNumeric())
{
allNumeric = false;
@@ -876,17 +837,17 @@
if (allFinite && !validators->elementAt(i)->getFinite())
{
allFinite = false;
- }
+ }
}
- if (commonAnc)
+ if (commonAnc)
{
datatypeValidator->setOrdered(validators->elementAt(0)->getOrdered());
- }
- else if (allOrderedFalse)
+ }
+ else if (allOrderedFalse)
{
datatypeValidator->setOrdered(XSSimpleTypeDefinition::ORDERED_FALSE);
- }
- else
+ }
+ else
{
datatypeValidator->setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
}
@@ -913,7 +874,7 @@
void DatatypeValidatorFactory::serialize(XSerializeEngine& serEng)
{
-
+
// Need not to serialize static data member, fBuiltInRegistry
if (serEng.isStoring())
@@ -925,12 +886,6 @@
}
else
{
- /***
- * DV in the UserDefinedRegistry rely on the fBuiltInRegistry
- * to resolve their built-in baseValidator
- ***/
- expandRegistryToFullSchemaSet();
-
/***
* Deserialize RefHashTableOf<DatatypeValidator>
***/
Modified: xerces/c/trunk/src/xercesc/validators/datatype/DatatypeValidatorFactory.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/validators/datatype/DatatypeValidatorFactory.hpp?rev=635560&r1=635559&r2=635560&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/validators/datatype/DatatypeValidatorFactory.hpp (original)
+++ xerces/c/trunk/src/xercesc/validators/datatype/DatatypeValidatorFactory.hpp Mon Mar 10 07:10:09 2008
@@ -5,9 +5,9 @@
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -111,12 +111,7 @@
//@}
- // -----------------------------------------------------------------------
- // Registry Initialization methods
- // -----------------------------------------------------------------------
- /** @name Registry Initialization Functions */
- //@{
-
+ private:
/**
* Initializes registry with primitive and derived Simple types.
*
@@ -127,12 +122,11 @@
* datatypes needed by the validator.
*
* If we start with Schema's then we initialize to full set of
- * validators.
+ * validators.
*/
void expandRegistryToFullSchemaSet();
- //@}
-
+ public:
// -----------------------------------------------------------------------
// Canonical Representation Group
// -----------------------------------------------------------------------
@@ -209,11 +203,6 @@
*/
void resetRegistry();
- // -----------------------------------------------------------------------
- // Notification that lazy data has been deleted
- // -----------------------------------------------------------------------
- static void reinitRegistry();
-
/***
* Support for Serialization/De-serialization
***/
@@ -247,6 +236,7 @@
XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* const fMemoryManager;
friend class XPath2ContextImpl;
+ friend class XMLInitializer;
};
inline DatatypeValidator*
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@xerces.apache.org
For additional commands, e-mail: commits-help@xerces.apache.org