import org.netbeans.modules.parsing.spi.ParserFactory; //导入依赖的package包/类
public Void run () throws Exception {
    final LowMemoryWatcher lMListener = LowMemoryWatcher.getInstance();
    Parser parser = null;
    final Collection<Snapshot> snapShots = new LazySnapshots(sources);
    for (Source source : sources) {
        if (parser == null) {
            Lookup lookup = MimeLookup.getLookup (source.getMimeType ());
            ParserFactory parserFactory = lookup.lookup (ParserFactory.class);
            if (parserFactory != null) {
                parser = parserFactory.createParser (snapShots);
            }
        }
        final SourceCache uncachedSourceCache = new SourceCache(source, null, parser);
        SourceCache origCache = SourceAccessor.getINSTANCE().getAndSetCache(source, uncachedSourceCache);
        final ResultIterator resultIterator = new ResultIterator (uncachedSourceCache, parser, userTask);
        try {
            TaskProcessor.callUserTask(userTask, resultIterator);
        } finally {
            ResultIteratorAccessor.getINSTANCE().invalidate(resultIterator);
            SourceAccessor.getINSTANCE().getAndSetCache(source, origCache);
        }
        if (lMListener.isLowMemory ())
            parser = null;
    }
    return null;
}
 

import org.netbeans.modules.parsing.spi.ParserFactory; //导入依赖的package包/类
/** Return a parser for use with this language. A parser is optional (in which
 * case getParser() may return null) but in that case a lot of functionality
 * will be disabled for this language.
 * @todo Clarify whether clients should cache instances of this or if it will
 *  be called only once and management done by the IDE
 */
@CheckForNull
public Parser getParser(Collection<Snapshot> snapshots) {
    Parser parser = null;

    if (parserFile != null) {
        // Lazily construct Parser
        ParserFactory factory = (ParserFactory)createInstance(parserFile);
        if (factory == null) {
            // Don't keep trying
            parserFile = null;
        } else {
            parser = factory.createParser(snapshots);
        }
    } else {
        getGsfLanguage(); // Also initializes languageConfig
        if (languageConfig != null) {
            parser = languageConfig.getParser();
        }
    }

    return parser;
}
 

import org.netbeans.modules.parsing.spi.ParserFactory; //导入依赖的package包/类
public Parser findMimeParser(Lookup context, final String mimeType) {
    Parser p = null;
    final Reference<Parser> ref = cachedParsers.get (mimeType);
    if (ref != null) {
        p = ref.get();
    }
    if (p == null) {
        final Lookup lookup = MimeLookup.getLookup (mimeType);
        final ParserFactory parserFactory = lookup.lookup (ParserFactory.class);
        if (parserFactory == null) {
            throw new IllegalArgumentException("No parser for mime type: " + mimeType);
        }
        p = parserFactory.createParser(Collections.<Snapshot>emptyList());
        cachedParsers.put(mimeType, new SoftReference<Parser>(p));
    }
    return p;
}
 

import org.netbeans.modules.parsing.spi.ParserFactory; //导入依赖的package包/类
@Override
public synchronized Parser findMimeParser(Lookup context, String mimeType) {
    Reference<Parser> rp = cachedParsers.get(mimeType);
    Parser p = null;
    if (rp != null) {
        p = rp.get();
    }
    if (p != null) {
        return p;
    }
    ParserFactory f = MimeLookup.getLookup(mimeType).lookup(ParserFactory.class);
    if (f != null) {
        p = f.createParser(Collections.<Snapshot>emptyList());
    } else {
        p = MimeLookup.getDefault().lookup(ParserFactory.class).createParser(Collections.<Snapshot>emptyList());
    }
    cachedParsers.put(mimeType, new WeakReference<>(p));
    return p;
}
 

import org.netbeans.modules.parsing.spi.ParserFactory; //导入依赖的package包/类
private static void registerParser(LayerBuilder b, String mimeType) {
        instanceFile(b, "Editors/" + mimeType, null, GsfParserFactory.class, "create", ParserFactory.class).write(); //NOI18N

//        // Parser factory
//        item = createFile(doc, mimeFolder, "org-netbeans-modules-csl-core-GsfParserFactory.instance"); // NOI18N
//        setFileAttribute(doc, item, "instanceCreate", METHODVALUE, "org.netbeans.modules.csl.core.GsfParserFactory.create"); //NOI18N
//        setFileAttribute(doc, item, "instanceOf", STRINGVALUE, "org.netbeans.modules.parsing.spi.ParserFactory"); //NOI18N
    }
 

import org.netbeans.modules.parsing.spi.ParserFactory; //导入依赖的package包/类
public Parser getParser () {
    synchronized (TaskProcessor.INTERNAL_LOCK) {
        if (parserInitialized) {
            return parser;
        }
    }
    Parser _parser = null;
    Lookup lookup = MimeLookup.getLookup (mimeType);
    ParserFactory parserFactory = lookup.lookup (ParserFactory.class);
    if (parserFactory != null) {
        final Snapshot _snapshot = getSnapshot ();
        final Collection<Snapshot> _tmp = Collections.singleton (_snapshot);
        _parser = parserFactory.createParser (_tmp);
        if (_parser == null) {
            LOG.log(
                Level.INFO,
                "Parser factory: {0} returned null parser for {1}", //NOI18N
                new Object[]{
                    parserFactory,
                    _snapshot
                });
        }
    }

    synchronized (TaskProcessor.INTERNAL_LOCK) {
        if (!parserInitialized) {                                                                                
            parser = _parser;
            if (parser != null) {
                parser.addChangeListener(WeakListeners.change(
                    SourceAccessor.getINSTANCE().getParserEventForward(source),
                    parser));
            }
            parserInitialized = true;
        }
        return parser;
    }
}
 

import org.netbeans.modules.parsing.spi.ParserFactory; //导入依赖的package包/类
public static JavacParserFactory getDefault () {
    final Lookup lookup = MimeLookup.getLookup (JavacParser.MIME_TYPE);
    return (JavacParserFactory)lookup.lookup (ParserFactory.class);       
}
 

import org.netbeans.modules.parsing.spi.ParserFactory; //导入依赖的package包/类
public static ParserFactory create(FileObject f) {
    String mimeType = f.getParent().getPath().substring("Editors/".length()); //NOI18N
    return new GsfParserFactory(mimeType);
}
 

import org.netbeans.modules.parsing.spi.ParserFactory; //导入依赖的package包/类
public static synchronized ParserFactory getDefault() {
    if(INSTANCE == null) {
        INSTANCE = new CssParserFactory();
    }
    return INSTANCE;
}
 

import org.netbeans.modules.parsing.spi.ParserFactory; //导入依赖的package包/类
@Override
public Parser findMimeParser(Lookup context, String mimeType) {
    return MimeLookup.getLookup(mimeType).lookup(ParserFactory.class).createParser(Collections.<Snapshot>emptySet());
}