import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
/**
 * Parse a grammar from a location identified by an
 * XMLInputSource.
 * This method also adds this grammar to the XMLGrammarPool
 *
 * @param type The type of the grammar to be constructed
 * @param is The XMLInputSource containing this grammar's
 * information
 * <strong>If a URI is included in the systemId field, the parser will not expand this URI or make it
 * available to the EntityResolver</strong>
 * @return The newly created <code>Grammar</code>.
 * @exception XNIException thrown on an error in grammar
 * construction
 * @exception IOException thrown if an error is encountered
 * in reading the file
 */
public Grammar preparseGrammar(String type, XMLInputSource
            is) throws XNIException, IOException {
    if (fLoaders.containsKey(type)) {
        XMLGrammarLoaderContainer xglc = (XMLGrammarLoaderContainer) fLoaders.get(type);
        XMLGrammarLoader gl = xglc.loader;
        if (xglc.modCount != fModCount) {
            // make sure gl's been set up with all the "basic" properties:
            gl.setProperty(SYMBOL_TABLE, fSymbolTable);
            gl.setProperty(ENTITY_RESOLVER, fEntityResolver);
            gl.setProperty(ERROR_REPORTER, fErrorReporter);
            // potentially, not all will support this one...
            if (fGrammarPool != null) {
                try {
                    gl.setProperty(GRAMMAR_POOL, fGrammarPool);
                } catch(Exception e) {
                    // too bad...
                }
            }
            xglc.modCount = fModCount;
        }
        return gl.loadGrammar(is);
    }
    return null;
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
DTDGrammar parseDTD(XMLInputSource is) 
            throws IOException {
    XMLEntityResolver resolver = getEntityResolver();
    if(resolver != null) {
        fDTDLoader.setEntityResolver(resolver);
    }
    fDTDLoader.setProperty(ERROR_REPORTER, fErrorReporter);

    // Should check whether the grammar with this namespace is already in
    // the grammar resolver. But since we don't know the target namespace
    // of the document here, we leave such check to the application...
    DTDGrammar grammar = (DTDGrammar)fDTDLoader.loadGrammar(is);
    // by default, hand it off to the grammar pool
    if (grammar != null) {
        fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_DTD,
                                  new Grammar[]{grammar});
    }
    
    return grammar;

}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
/**
 * Returns the grammar associated to the specified grammar description.
 * Currently, the root element name is used as the key for DTD grammars
 * and the target namespace  is used as the key for Schema grammars.
 *
 * @param desc The Grammar Description.
 */
public Grammar getGrammar(XMLGrammarDescription desc) {
    synchronized (fGrammars) {
        clean();
        int hash = hashCode(desc);
        int index = (hash & 0x7FFFFFFF) % fGrammars.length;
        for (Entry entry = fGrammars[index]; entry != null; entry = entry.next) {
            Grammar tempGrammar = (Grammar) entry.grammar.get();
            /** If the soft reference has been cleared, remove this entry from the pool. */
            if (tempGrammar == null) {
                removeEntry(entry);
            }
            else if ((entry.hash == hash) && equals(entry.desc, desc)) {
                return tempGrammar;
            }
        }
        return null;
    }
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
/**
 * Returns true if the grammar pool contains a grammar associated
 * to the specified grammar description. Currently, the root element name
 * is used as the key for DTD grammars and the target namespace  is used
 * as the key for Schema grammars.
 *
 * @param desc The Grammar Description.
 */
public boolean containsGrammar(XMLGrammarDescription desc) {
    synchronized (fGrammars) {
        clean();
        int hash = hashCode(desc);
        int index = (hash & 0x7FFFFFFF) % fGrammars.length;
        for (Entry entry = fGrammars[index]; entry != null ; entry = entry.next) {
            Grammar tempGrammar = (Grammar) entry.grammar.get();
            /** If the soft reference has been cleared, remove this entry from the pool. */
            if (tempGrammar == null) {
                removeEntry(entry);
            }
            else if ((entry.hash == hash) && equals(entry.desc, desc)) {
                return true;
            }
        }
        return false;
    }
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
public Grammar [] retrieveInitialGrammarSet (String grammarType) {
    synchronized (fGrammars) {
        int grammarSize = fGrammars.length ;
        Grammar [] tempGrammars = new Grammar[fGrammarCount];
        int pos = 0;
        for (int i = 0; i < grammarSize; i++) {
            for (Entry e = fGrammars[i]; e != null; e = e.next) {
                if (e.desc.getGrammarType().equals(grammarType)) {
                    tempGrammars[pos++] = e.grammar;
                }
            }
        }
        Grammar[] toReturn = new Grammar[pos];
        System.arraycopy(tempGrammars, 0, toReturn, 0, pos);
        return toReturn;
    }
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
/**
 * Removes the grammar associated to the specified grammar description from the
 * grammar pool and returns the removed grammar. Currently, the root element name
 * is used as the key for DTD grammars and the target namespace  is used
 * as the key for Schema grammars.
 *
 * @param desc The Grammar Description.
 * @return     The removed grammar.
 */
public Grammar removeGrammar(XMLGrammarDescription desc) {
    synchronized (fGrammars) {
        int hash = hashCode(desc);
    int index = (hash & 0x7FFFFFFF) % fGrammars.length;
    for (Entry entry = fGrammars[index], prev = null ; entry != null ; prev = entry, entry = entry.next) {
        if ((entry.hash == hash) && equals(entry.desc, desc)) {
            if (prev != null) {
                    prev.next = entry.next;
        }
        else {
            fGrammars[index] = entry.next;
        }
            Grammar tempGrammar = entry.grammar;
            entry.grammar = null;
            fGrammarCount--;
            return tempGrammar;
        }
    }
    return null;
    }
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
private void initGrammarBucket(){
    if(fGrammarPool != null) {
        Grammar [] initialGrammars = fGrammarPool.retrieveInitialGrammarSet(XMLGrammarDescription.XML_SCHEMA);
        final int length = (initialGrammars != null) ? initialGrammars.length : 0;
        for (int i = 0; i < length; ++i) {
            // put this grammar into the bucket, along with grammars
            // imported by it (directly or indirectly)
            if (!fGrammarBucket.putGrammar((SchemaGrammar)(initialGrammars[i]), true)) {
                // REVISIT: a conflict between new grammar(s) and grammars
                // in the bucket. What to do? A warning? An exception?
                fErrorReporter.reportError(XSMessageFormatter.SCHEMA_DOMAIN,
                        "GrammarConflict", null,
                        XMLErrorReporter.SEVERITY_WARNING);
            }
        }
    }
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
private void initGrammarPool(ASModelImpl currModel, XMLGrammarPool grammarPool) {
    // put all the grammars in fAbstractSchema into the grammar pool.
    // grammarPool must never be null!
    Grammar[] grammars = new Grammar[1];
    if ((grammars[0] = (Grammar)currModel.getGrammar()) != null) {
        grammarPool.cacheGrammars(grammars[0].getGrammarDescription().getGrammarType(), grammars);
    }
    Vector modelStore = currModel.getInternalASModels();
    for (int i = 0; i < modelStore.size(); i++) {
        initGrammarPool((ASModelImpl)modelStore.elementAt(i), grammarPool);
    }
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
/**
 * Returns the grammar associated to the specified description.
 * 
 * @param desc The description of the grammar.
 */
public Grammar getGrammar(XMLGrammarDescription desc) {

    if (super.containsGrammar(desc)) {
        return super.getGrammar(desc);
    }
    return null;

}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
SchemaGrammar parseXMLSchema(XMLInputSource is) 
            throws IOException {
    XMLEntityResolver resolver = getEntityResolver();
    if(resolver != null) {
        fSchemaLoader.setEntityResolver(resolver);
    }
    if (fErrorReporter.getMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN) == null) {
        fErrorReporter.putMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN, new XSMessageFormatter());
    } 
    fSchemaLoader.setProperty(ERROR_REPORTER, fErrorReporter);

    String propPrefix = Constants.XERCES_PROPERTY_PREFIX;
    String propName = propPrefix + Constants.SCHEMA_LOCATION;
    fSchemaLoader.setProperty(propName, getProperty(propName));
    propName = propPrefix + Constants.SCHEMA_NONS_LOCATION;
    fSchemaLoader.setProperty(propName, getProperty(propName));
    propName = Constants.JAXP_PROPERTY_PREFIX+Constants.SCHEMA_SOURCE;
    fSchemaLoader.setProperty(propName, getProperty(propName));
    fSchemaLoader.setFeature(SCHEMA_FULL_CHECKING, getFeature(SCHEMA_FULL_CHECKING));

    // Should check whether the grammar with this namespace is already in
    // the grammar resolver. But since we don't know the target namespace
    // of the document here, we leave such check to XSDHandler
    SchemaGrammar grammar = (SchemaGrammar)fSchemaLoader.loadGrammar(is);
    // by default, hand it off to the grammar pool
    if (grammar != null) {
        fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_SCHEMA,
                                  new Grammar[]{grammar});
    }
    
    return grammar;

}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
public Grammar [] retrieveInitialGrammarSet (String grammarType) {
    synchronized (fGrammars) {
        clean();
        // Return no grammars. This allows the garbage collector to sift
        // out grammars which are not in use when memory demand is high.
        // It also allows the pool to return the "right" schema grammar
        // based on schema locations.
        return ZERO_LENGTH_GRAMMAR_ARRAY;
    }
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
public void cacheGrammars(String grammarType, Grammar[] grammars) {
    if (!fPoolIsLocked) {
        for (int i = 0; i < grammars.length; ++i) {
            putGrammar(grammars[i]);
        }
    }
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
/**
 * Removes the grammar associated to the specified grammar description from the
 * grammar pool and returns the removed grammar. Currently, the root element name
 * is used as the key for DTD grammars and the target namespace  is used
 * as the key for Schema grammars.
 *
 * @param desc The Grammar Description.
 * @return     The removed grammar.
 */
public Grammar removeGrammar(XMLGrammarDescription desc) {
    synchronized (fGrammars) {
        clean();
        int hash = hashCode(desc);
        int index = (hash & 0x7FFFFFFF) % fGrammars.length;
        for (Entry entry = fGrammars[index]; entry != null; entry = entry.next) {
            if ((entry.hash == hash) && equals(entry.desc, desc)) {
                return removeEntry(entry);
            }
        }
        return null;
    }
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
/**
 * Removes the given entry from the pool
 * 
 * @param entry the entry to remove
 * @return The grammar attached to this entry
 */
private Grammar removeEntry(Entry entry) {
    if (entry.prev != null) {
        entry.prev.next = entry.next;
    }
    else {
        fGrammars[entry.bucket] = entry.next;
    }
    if (entry.next != null) {
        entry.next.prev = entry.prev;
    }
    --fGrammarCount;
    entry.grammar.entry = null;
    return (Grammar) entry.grammar.get();
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
protected Entry(int hash, int bucket, XMLGrammarDescription desc, Grammar grammar, Entry next, ReferenceQueue queue) {
    this.hash = hash;
    this.bucket = bucket;
    this.prev = null;
    this.next = next;
    if (next != null) {
        next.prev = this;
    }
    this.desc = desc;
    this.grammar = new SoftGrammarReference(this, grammar, queue);
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
public void cacheGrammars(String grammarType, Grammar[] grammars) {
    if(!fPoolIsLocked) {
        for (int i = 0; i < grammars.length; i++) {
            if(DEBUG) {
                System.out.println("CACHED GRAMMAR " + (i+1) ) ;
                Grammar temp = grammars[i] ;
                //print(temp.getGrammarDescription());
            }
            putGrammar(grammars[i]);
        }
    }
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
public Grammar retrieveGrammar(XMLGrammarDescription desc) {
    if(DEBUG){
        System.out.println("RETRIEVING GRAMMAR FROM THE APPLICATION WITH FOLLOWING DESCRIPTION :");
        //print(desc);
    }
    return getGrammar(desc);
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
/**
 * Returns the grammar associated to the specified grammar description.
 * Currently, the root element name is used as the key for DTD grammars
 * and the target namespace  is used as the key for Schema grammars.
 *
 * @param desc The Grammar Description.
 */
public Grammar getGrammar(XMLGrammarDescription desc) {
    synchronized (fGrammars) {
        int hash = hashCode(desc);
    int index = (hash & 0x7FFFFFFF) % fGrammars.length;
    for (Entry entry = fGrammars[index] ; entry != null ; entry = entry.next) {
        if ((entry.hash == hash) && equals(entry.desc, desc)) {
            return entry.grammar;
        }
    }
    return null;
}
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
/**
 * Returns a Grammar object by parsing the contents of the
 * entity pointed to by source.
 *
 * @param source        the location of the entity which forms
 *                          the starting point of the grammar to be constructed.
 * @throws IOException      When a problem is encountered reading the entity
 *          XNIException    When a condition arises (such as a FatalError) that requires parsing
 *                              of the entity be terminated.
 */
public Grammar loadGrammar(XMLInputSource source)
        throws IOException, XNIException {
    reset();
    // First chance checking strict URI
    String eid = XMLEntityManager.expandSystemId(source.getSystemId(), source.getBaseSystemId(), fStrictURI);
    XMLDTDDescription desc = new XMLDTDDescription(source.getPublicId(), source.getSystemId(), source.getBaseSystemId(), eid, null);
    if (!fBalanceSyntaxTrees) {
        fDTDGrammar = new DTDGrammar(fSymbolTable, desc);
    }
    else {
        fDTDGrammar = new BalancedDTDGrammar(fSymbolTable, desc);
    }
    fGrammarBucket = new DTDGrammarBucket();
    fGrammarBucket.setStandalone(false);
    fGrammarBucket.setActiveGrammar(fDTDGrammar); 
    // no reason to use grammar bucket's "put" method--we
    // know which grammar it is, and we don't know the root name anyway...

    // actually start the parsing!
    try {
        fDTDScanner.setInputSource(source);
        fDTDScanner.scanDTDExternalSubset(true);
    } catch (EOFException e) {
        // expected behaviour...
    }
    finally {
        // Close all streams opened by the parser.
        fEntityManager.closeReaders();
    }
    if(fDTDGrammar != null && fGrammarPool != null) {
        fGrammarPool.cacheGrammars(XMLDTDDescription.XML_DTD, new Grammar[] {fDTDGrammar});
    }
    return fDTDGrammar;
}
 

import org.apache.xerces.xni.grammars.Grammar; //导入依赖的package包/类
/**
 * Returns a Grammar object by parsing the contents of the
 * entity pointed to by source.
 *
 * @param source        the location of the entity which forms
 *                          the starting point of the grammar to be constructed.
 * @throws IOException      When a problem is encountered reading the entity
 *          XNIException    When a condition arises (such as a FatalError) that requires parsing
 *                              of the entity be terminated.
 */
public Grammar loadGrammar(XMLInputSource source)
throws IOException, XNIException {
    
    // REVISIT: this method should have a namespace parameter specified by 
    // user. In this case we can easily detect if a schema asked to be loaded
    // is already in the local cache.
    
    reset(fLoaderConfig);
    fSettingsChanged = false;
    XSDDescription desc = new XSDDescription();
    desc.fContextType = XSDDescription.CONTEXT_PREPARSE;
    desc.setBaseSystemId(source.getBaseSystemId());
    desc.setLiteralSystemId( source.getSystemId());
    // none of the other fields make sense for preparsing
    Hashtable locationPairs = new Hashtable();
    // Process external schema location properties.
    // We don't call tokenizeSchemaLocationStr here, because we also want
    // to check whether the values are valid URI.
    processExternalHints(fExternalSchemas, fExternalNoNSSchema,
            locationPairs, fErrorReporter);
    SchemaGrammar grammar = loadSchema(desc, source, locationPairs);
    
    if(grammar != null && fGrammarPool != null) {
        fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_SCHEMA, fGrammarBucket.getGrammars());
        // NOTE: we only need to verify full checking in case the schema was not provided via JAXP
        // since full checking already verified for all JAXP schemas
        if(fIsCheckedFully && fJAXPCache.get(grammar) != grammar) {
            XSConstraints.fullSchemaChecking(fGrammarBucket, fSubGroupHandler, fCMBuilder, fErrorReporter);
        }
    }
    return grammar;
}