import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
private void init(final Task task) {
    if (!initialized) {
        ClasspathInfo _tmpInfo = null;
        if (task instanceof ClasspathInfo.Provider &&
            (_tmpInfo = ((ClasspathInfo.Provider)task).getClasspathInfo()) != null) {
            if (cpInfo != null && weakCpListener != null) {
                cpInfo.removeChangeListener(weakCpListener);
                this.weakCpListener = null;
            }
            cpInfo = _tmpInfo;
            this.weakCpListener = WeakListeners.change(cpInfoListener, cpInfo);
            cpInfo.addChangeListener (this.weakCpListener);
            root = Optional.ofNullable(cpInfo.getClassPath(PathKind.SOURCE))
                    .map((cp)-> {
                        FileObject[] roots = cp.getRoots();
                        return roots.length > 0 ? roots[0] : null;
                    })
                    .orElse(null);
        } else {
            throw new IllegalArgumentException("No classpath provided by task: " + task);
        }
        initialized = true;
    }
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public void parse(Snapshot snapshot, Task task, SourceModificationEvent event) throws ParseException {
    final CharSequence toParse = snapshot.getText();
    boolean valid = true;
    int embStart = -1;
    for (int i=0; i< toParse.length(); i++) {
        if (toParse.charAt(i) == '<') {         //NOI18N
            if (embStart != -1) {
                valid = false;
                break;
            }
            embStart = i+1;
        } else if (toParse.charAt(i) == '>') {  //NOI18N
            if (embStart == -1 || embStart == i) {
                valid = false;
                break;
            }
            embStart = -1;
        }
    }
    resultCache = new TopResult(snapshot, valid);
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
/**
 * Called by infrastructure when Source is changed, and a new Snapshot has been created for it.
 *
 * @param snapshot A snapshot that should be parsed.
 * @param task A task asking for parsing result.
 * @param event A scheduler event
 */
@Override
public void parse(Snapshot snapshot, Task task, SourceModificationEvent event) {
    this.snapshot = snapshot;
    Reader reader = new StringReader(snapshot.getText().toString());
    apexParser = new ApexParser(reader);
    apexParser.setTreeFactory(new ApexTreeFactory());
    try {
        if (snapshot.getMimeType().equalsIgnoreCase(ApexLanguageHierarchy.APEX_MIME_TYPE)) {

            compilationUnit = apexParser.CompilationUnit();
        } else if (snapshot.getMimeType().equalsIgnoreCase(ApexLanguageHierarchy.APEX_TRIGGER_MIME_TYPE)){
            compilationUnit = apexParser.TriggerCompilationUnit();
        }

    } catch (org.fundacionjala.oblivion.apex.grammar.jcclexer.ParseException ex) {
        apexParser.contextErrorRecover(ex);
    } catch (java.lang.Error error){
        error.printStackTrace();
    }
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public Result getResult(Task task) throws ParseException {
    return new ParserResult(snapshot) {

        @Override
        public List<? extends Error> getDiagnostics() {
            Document document = snapshot.getSource().getDocument(false);
            if (document != null) {
                return RoutesValidator.validateFile(document);
            } else {
                return Collections.EMPTY_LIST;
            }
        }

        @Override
        protected void invalidate() {
        }
    };
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public void parse(Snapshot snapshot, Task task, SourceModificationEvent event) throws ParseException {
    this.snapshot = snapshot;
    String text = snapshot.getText().toString();
    ANTLRInputStream input = new ANTLRInputStream(text);
    Lexer lexer = new EditorConfigLexer(input);
    lexer.removeErrorListeners();

    CommonTokenStream tokens = new CommonTokenStream(lexer);
    parser = new EditorConfigParser(tokens);
    parser.removeErrorListeners();
    syntaxErrors = new ArrayList<>();
    EditorConfigErrorListener errorListener = new EditorConfigErrorListener(syntaxErrors);
    parser.addErrorListener(errorListener);
    EditorConfigParser.FileContext root = parser.file();
    result = new ECParserResult(snapshot, parser, root);
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public void parse(Snapshot snapshot, Task task, SourceModificationEvent sme) throws ParseException {
    this.snapshot = snapshot;
    parserExceptions = new ArrayList<>();
    ANTLRInputStream is = new ANTLRInputStream(snapshot.getText().toString());
    StpLexer lexer = new StpLexer(is);
    CommonTokenStream tokenStream = new CommonTokenStream(lexer);
    parser = new StpParser(tokenStream);
    parser.removeErrorListeners();
    parser.addErrorListener(new SilverstripeParserErrorListener());
    try {
        templateContext = parser.template();
    } catch(SilverstripeParserException ex) {
        parserExceptions.add(ex);
    } catch (RuntimeException e) {
        LOG.log(Level.WARNING, e.getMessage(), e);
    }
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public void parse(Snapshot snapshot, Task task, SourceModificationEvent sme)
        throws ParseException {

    String oldContent = lastContent.get(
            snapshot.getSource().getDocument(false)
    );

    String newContent = snapshot.getText().toString();

    boolean changed = oldContent == null || !oldContent.equals(newContent);

    if (sme.sourceChanged() && changed) {
        lastContent.put(
                snapshot.getSource().getDocument(false),
                newContent
        );
        reparse(snapshot);
    } else if ( result == null ){
        result = new NBMirahParserResult(snapshot, diag);
        getBlocks(result, newContent);
        
    }

}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public void parse(Snapshot snapshot, Task task, SourceModificationEvent event) throws ParseException {
  this.snapshot = snapshot;
  String text = snapshot.getText().toString();
  ANTLRInputStream input = new ANTLRInputStream(text);
  Lexer lexer = new EditorConfigLexer(input);
  lexer.removeErrorListeners();

  CommonTokenStream tokens = new CommonTokenStream(lexer);
  parser = new EditorConfigParser(tokens);
  parser.removeErrorListeners();
  syntaxErrors = new ArrayList<>();
  EditorConfigErrorListener errorListener = new EditorConfigErrorListener(syntaxErrors);
  parser.addErrorListener(errorListener);
  EditorConfigParser.FileContext root = parser.file();
  result = new ECParserResult(snapshot, parser, root);
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
    public void parse(Snapshot snapshot, Task task, SourceModificationEvent event) {
        this.snapshot = snapshot;
        Document document = snapshot.getSource().getDocument(true);
        syntaxErrors = (List<SyntaxError>) document.getProperty("syntaxErrors");
        if (syntaxErrors == null) {
            syntaxErrors = new ArrayList<>();
            document.putProperty("syntaxErrors", syntaxErrors);
        }
        embeddedOffset = snapshot.getOriginalOffset(0);
//        Logger.Log("macparse: " + syntaxErrors.size() + " - " + embeddedOffset);
        if (embeddedOffset <= 0) {
            syntaxErrors.clear();
        }
        ANTLRInputStream input = new ANTLRInputStream(snapshot.getText().toString());
        Lexer lexer = new macLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        macParser = new macParser(tokens);
        macParser.removeErrorListeners();
        macParser.addErrorListener(new ErrorListener(syntaxErrors, embeddedOffset));
        try {
            ProgContext prog = macParser.prog();
        } catch (RecognitionException ex) {
            ex.printStackTrace();
        }
    }
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public Result getResult(Task task) throws ParseException {
    if (this.result == null) {
        this.result = new DeclarativeHintsParser().parse(snapshot.getSource().getFileObject(),
                                                         snapshot.getText(),
                                                         snapshot.getTokenHierarchy().tokenSequence(DeclarativeHintTokenId.language()));
    }

    return new ResultImpl(snapshot, result);
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public void parse(final Snapshot snapshot, final Task task, SourceModificationEvent event) throws ParseException {
    try {
        checkSourceModification(event);
        parseImpl(snapshot, task);
    } catch (FileObjects.InvalidFileException ife) {
        //pass - already invalidated in parseImpl
    } catch (IOException ioe) {
        throw new ParseException ("JavacParser failure", ioe); //NOI18N
    }
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
private boolean shouldParse(@NonNull Task task) {
    if (!(task instanceof MimeTask)) {
        currentSource = null;
        return true;
    }
    final JavaSource newSource = ((MimeTask)task).getJavaSource();
    if (invalid) {
        currentSource = new WeakReference<>(newSource);
        return true;
    }
    final JavaSource oldSource = currentSource == null ?
            null :
            currentSource.get();
    if (oldSource == null) {
        currentSource = new WeakReference<>(newSource);
        return true;
    }
    if (newSource.equals(oldSource)) {
        return false;
    }
    if (newSource.getClasspathInfo() == oldSource.getClasspathInfo()) {
        currentSource = new WeakReference<>(newSource);
        return false;
    }
    currentSource = new WeakReference<>(newSource);
    return true;
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
@NonNull
public Result getResult(Task task) throws ParseException {
    if (current == null) {
        throw new IllegalStateException("No current snapshot"); //NOI18N
    }
    return new DockerfileResult(current);
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
private Task createTask(ClasspathInfo cpInfo, JTextComponent component,
        CompletionResultSet rs, Document doc, int caretOffset, int qT) {
    return new Task(cpInfo, 
            component, 
            rs, 
            doc, caretOffset, qT);
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
public Task(ClasspathInfo cpInfo, JTextComponent component, CompletionResultSet resultSet, Document doc, int caretOffset, int queryType) {
    this.resultSet = resultSet;
    this.doc = doc;
    this.caretOffset = caretOffset;
    this.component = component;
    this.cpInfo = cpInfo;
    this.queryType = queryType;
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public void parse(Snapshot snapshot, Task task, SourceModificationEvent event) throws ParseException {
    Document d = snapshot.getSource().getDocument(false);
    if (d == null) {
        return;
    }
    ShellSession ss = ShellSession.get(d);
    if (ss == null) {
        return;
    }
    ConsoleContents cc = buildConsoleContents(ss, snapshot);
    if (cc != null) {
        result = new SoftReference<>(cc);
    }
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public Result getResult(Task task) throws ParseException {
    return new Result(snapshot) {
        @Override
        protected void invalidate() {
        }
    };
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
@Override
public Result getResult(Task task) throws ParseException {
    final Snapshot snapshot = this.currentSnapshot;
    if (snapshot == null) {
        throw new IllegalStateException("No Snapshot"); //NOI18N
    }
    return new Result(snapshot) {
        @Override
        protected void invalidate() {
        }
    };
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
public static void callParse(
    final @NonNull Parser parser,
    final @NullAllowed Snapshot snapshot,
    final @NonNull Task task,
    final @NullAllowed SourceModificationEvent event) throws ParseException {
    assert parser != null;
    assert task != null;
    assert !Thread.holdsLock(INTERNAL_LOCK);
    assert parserLock.isHeldByCurrentThread();
    parser.parse(snapshot, task, event);
}
 

import org.netbeans.modules.parsing.api.Task; //导入依赖的package包/类
public static Parser.Result callGetResult(
        final @NonNull Parser parser,
        final @NonNull Task task) throws ParseException {
    assert parser !=  null;
    assert task != null;
    assert !Thread.holdsLock(INTERNAL_LOCK);
    assert parserLock.isHeldByCurrentThread();
    return parser.getResult(task);

}