Esempio n. 1
0
bool XMLSynchronizedStringPool::exists(const XMLCh* const newString) const
{
    if(fConstPool->exists(newString))
        return true;

    XMLMutexLock lockInit(&const_cast<XMLSynchronizedStringPool*>(this)->fMutex);
    return XMLStringPool::exists(newString);
}
Esempio n. 2
0
const XMLCh* XMLSynchronizedStringPool::getValueForId(const unsigned int id) const
{
    if (id <= fConstPool->getStringCount())
        return fConstPool->getValueForId(id);

    unsigned int constCount = fConstPool->getStringCount();
    XMLMutexLock lockInit(&const_cast<XMLSynchronizedStringPool*>(this)->fMutex);
    return XMLStringPool::getValueForId(id-constCount);
}
Esempio n. 3
0
unsigned int XMLSynchronizedStringPool::getId(const XMLCh* const toFind) const
{
    unsigned int retVal = fConstPool->getId(toFind);
    if(retVal)
        return retVal;

    // make sure we return a truly unique id
    unsigned int constCount = fConstPool->getStringCount();
    XMLMutexLock lockInit(&const_cast<XMLSynchronizedStringPool*>(this)->fMutex);
    return XMLStringPool::getId(toFind)+constCount;
}
Esempio n. 4
0
// ---------------------------------------------------------------------------
//  XMLSynchronizedStringPool: Pool management methods
// ---------------------------------------------------------------------------
unsigned int XMLSynchronizedStringPool::addOrFind(const XMLCh* const newString)
{
    unsigned int id = fConstPool->getId(newString);
    if(id)
        return id;
    // might have to add it to our own table.
    // synchronize this bit
    unsigned int constCount = fConstPool->getStringCount();
    XMLMutexLock lockInit(&fMutex);
    id = XMLStringPool::addOrFind(newString);
    return id+constCount;
}
Esempio n. 5
0
static XMLMutex& getErrRprtrMutex()
{
    if (!sErrRprtrMutex)
    {
        XMLMutexLock lockInit(XMLPlatformUtils::fgAtomicMutex);

        if (!sErrRprtrMutex)
        {
            sErrRprtrMutex = new XMLMutex(XMLPlatformUtils::fgMemoryManager);
            errRprtrMutexCleanup.registerCleanup(reinitErrRprtrMutex);
        }
    }

    return *sErrRprtrMutex;
}
Esempio n. 6
0
Error hmInit(Address addr)
{
    start = (HmEntry)addr;
    start->next = (HmEntry)((unsigned long)addr + KERNELHEAPSIZE + 
							    sizeof(HmEntryDesc));
    start->status = HM_FREED;
    
    end = start->next;
    end->next = NULL;
    end->status = HM_ALLOCATED;
    
    hmLock = &hmLockDesc;
    lockInit( hmLock);
    
    return HM_INITOK;
}
Esempio n. 7
0
//
//  We need to fault in this mutex. But, since its used for synchronization
//  itself, we have to do this the low level way using a compare and swap.
//
static XMLMutex& gMsgMutex()
{
    if (!sScannerMutexRegistered)
    {
        XMLMutexLock lockInit(XMLPlatformUtils::fgAtomicMutex);

        if (!sScannerMutexRegistered)
        {
            sMsgMutex = new XMLMutex;
            msgMutexCleanup.registerCleanup(XMLException::reinitMsgMutex);
            sScannerMutexRegistered = true;
        }
    }

    return *sMsgMutex;
}
Esempio n. 8
0
// ---------------------------------------------------------------------------
//  RangeTokenMap: Initialization methods
// ---------------------------------------------------------------------------
void RangeTokenMap::initializeRegistry() {

    if (!fRegistryInitialized)
    {
        XMLMutexLock lockInit(&fMutex);

        if (!fRegistryInitialized)
        {
            fTokenFactory = new TokenFactory();
            fTokenRegistry = new RefHashTableOf<RangeTokenElemMap>(109);
            fRangeMap = new RefHashTableOf<RangeFactory>(29);
            fCategories = new XMLStringPool(109);
            fRegistryInitialized = true;
        }
    }
}
Esempio n. 9
0
bool XMLSynchronizedStringPool::exists(const unsigned int id) const
{
    if (!id)
        return false;

    // First see if this id belongs to the const pool.
    //
    unsigned int constCount = fConstPool->getStringCount();

    if (id <= constCount)
      return true;

    // The rest needs to be synchronized.
    //
    XMLMutexLock lockInit(&const_cast<XMLSynchronizedStringPool*>(this)->fMutex);
    return id < fCurId + constCount;
}
Esempio n. 10
0
// ---------------------------------------------------------------------------
//  RangeTokenMap: Getter methods
// ---------------------------------------------------------------------------
RangeToken* RangeTokenMap::getRange(const XMLCh* const keyword,
								    const bool complement) {

    if (fTokenRegistry == 0 || fRangeMap == 0 || fCategories == 0)
        return 0;

    if (!fTokenRegistry->containsKey(keyword))
        return 0;

    RangeTokenElemMap* elemMap = fTokenRegistry->get(keyword);
    RangeToken* rangeTok = elemMap->getRangeToken(complement);

    if (!rangeTok)
    {
        XMLMutexLock lockInit(&fMutex);

        // make sure that it was not created while we were locked
        rangeTok = elemMap->getRangeToken(complement);

        if (!rangeTok)
        {
            rangeTok = elemMap->getRangeToken();
            if (!rangeTok)
            {
                unsigned int categId = elemMap->getCategoryId();
                const XMLCh* categName = fCategories->getValueForId(categId);
                RangeFactory* rangeFactory = fRangeMap->get(categName);

                if (rangeFactory == 0)
                    return 0;

                rangeFactory->buildRanges();
                rangeTok = elemMap->getRangeToken();
            }

            if (complement)
            {
                rangeTok = (RangeToken*) RangeToken::complementRanges(rangeTok, fTokenFactory, fTokenRegistry->getMemoryManager());
                elemMap->setRangeToken(rangeTok , complement);
            }
        }
    }

    return rangeTok;
}
Esempio n. 11
0
// ---------------------------------------------------------------------------
//  TokenFactory - Helper methods
// ---------------------------------------------------------------------------
void TokenFactory::initializeRegistry() {

    if (!fRangeInitialized)
    {
        XMLMutexLock lockInit(&gTokenFactoryMutex());

        if (!fRangeInitialized) {

            RangeTokenMap::instance()->initializeRegistry();

            // Add categories
            RangeTokenMap::instance()->addCategory(fgXMLCategory);
            RangeTokenMap::instance()->addCategory(fgASCIICategory);
            RangeTokenMap::instance()->addCategory(fgUnicodeCategory);
            RangeTokenMap::instance()->addCategory(fgBlockCategory);

        	// Add xml range factory
            RangeFactory* rangeFact = new XMLRangeFactory();
            RangeTokenMap::instance()->addRangeMap(fgXMLCategory, rangeFact);
            rangeFact->initializeKeywordMap();

            // Add ascii range factory
            rangeFact = new ASCIIRangeFactory();
            RangeTokenMap::instance()->addRangeMap(fgASCIICategory, rangeFact);
            rangeFact->initializeKeywordMap();

            // Add unicode range factory
            rangeFact = new UnicodeRangeFactory();
            RangeTokenMap::instance()->addRangeMap(fgUnicodeCategory, rangeFact);
            rangeFact->initializeKeywordMap();

            // Add block range factory
            rangeFact = new BlockRangeFactory();
            RangeTokenMap::instance()->addRangeMap(fgBlockCategory, rangeFact);
            rangeFact->initializeKeywordMap();

            fRangeInitialized = true;
        }
    }
}
Esempio n. 12
0
//
//  This method is a lazy evaluator for the message loader for exception
//  messages.
//
static XMLMsgLoader& gGetMsgLoader()
{
    if (!sMsgLoader)
    {
        // Lock the message loader mutex and load the text
	    XMLMutexLock lockInit(&gMsgMutex());

        // Fault it in on first request
        if (!sMsgLoader)
        {
            sMsgLoader = XMLPlatformUtils::loadMsgSet(XMLUni::fgExceptDomain);
            if (!sMsgLoader)
                XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);

            //
            // Register this XMLMsgLoader for cleanup at Termination.
            //
            msgLoaderCleanup.registerCleanup(XMLException::reinitMsgLoader);
        }
    }

    // We got it, so return it
    return *sMsgLoader;
}
Esempio n. 13
0
/*
 * Prepares for matching. This method is called just before starting matching
 */
void RegularExpression::prepare() {

	XMLMutexLock lockInit(&fMutex);

	compile(fTokenTree);

	fMinLength = fTokenTree->getMinLength();
	fFirstChar = 0;

	if (!isSet(fOptions, PROHIBIT_HEAD_CHARACTER_OPTIMIZATION) &&
		!isSet(fOptions, XMLSCHEMA_MODE))							{

		RangeToken* rangeTok = fTokenFactory->createRange();
		int result = fTokenTree->analyzeFirstCharacter(rangeTok, fOptions, fTokenFactory);

		if (result == Token::FC_TERMINAL) {

			rangeTok->compactRanges();
			fFirstChar = rangeTok;
		}
	}

	if (fOperations != 0 && fOperations->getNextOp() == 0 &&
		(fOperations->getOpType() == Op::O_STRING ||
		 fOperations->getOpType() == Op::O_CHAR) )			 {

		fFixedStringOnly = true;

		if (fOperations->getOpType() == Op::O_STRING) {
			fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
			fFixedString = XMLString::replicate(fOperations->getLiteral(), fMemoryManager);
		}
		else{
			
			XMLInt32 ch = fOperations->getData();

			if ( ch >= 0x10000) { // add as constant
				fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
				fFixedString = RegxUtil::decomposeToSurrogates(ch, fMemoryManager);
			}
			else {

				XMLCh* dummyStr = (XMLCh*) fMemoryManager->allocate(2 * sizeof(XMLCh));//new XMLCh[2];
				dummyStr[0] = (XMLCh) fOperations->getData();
				dummyStr[1] = chNull;
				fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
				fFixedString = dummyStr;
			}
		}

		fBMPattern = new (fMemoryManager) BMPattern(fFixedString, 256,
								  isSet(fOptions, IGNORE_CASE), fMemoryManager);
	}
	else if (!isSet(fOptions, XMLSCHEMA_MODE) &&
			 !isSet(fOptions, PROHIBIT_FIXED_STRING_OPTIMIZATION)) {

		int fixedOpts = 0;
		Token* tok = fTokenTree->findFixedString(fOptions, fixedOpts);

		fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;

		fFixedString = (tok == 0) ? 0
			: XMLString::replicate(tok->getString(), fMemoryManager);

		if (fFixedString != 0 && XMLString::stringLen(fFixedString) < 2) {

			fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
			fFixedString = 0;
		}
		
		if (fFixedString != 0) {

			fBMPattern = new (fMemoryManager) BMPattern(fFixedString, 256,
									   isSet(fixedOpts, IGNORE_CASE));
		}
	}
}
Esempio n. 14
0
unsigned int XMLSynchronizedStringPool::getStringCount() const
{
    unsigned int constCount = fConstPool->getStringCount();
    XMLMutexLock lockInit(&const_cast<XMLSynchronizedStringPool*>(this)->fMutex);
    return fCurId+constCount-1;
}