Attachment #154399 for bug #241009

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 241009
Collapse All | Expand All

Lines 40-48 Link Here

(-)a/csl.api/nbproject/project.properties (-2 / +2 lines)
40	# Version 2 license, then the option applies only if the new code is	40	# Version 2 license, then the option applies only if the new code is
41	# made subject to such option by the copyright holder.	41	# made subject to such option by the copyright holder.
42		42
43	spec.version.base=2.49.0	43	spec.version.base=2.50.0
44	is.autoload=true	44	is.autoload=true
45	javac.source=1.6	45	javac.source=1.7
46		46
47	javadoc.overview=${basedir}/doc/overview.html	47	javadoc.overview=${basedir}/doc/overview.html
48	javadoc.arch=${basedir}/arch.xml	48	javadoc.arch=${basedir}/arch.xml




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2015 Sun Microsystems, Inc.
 */
package org.netbeans.modules.csl.core;

import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.modules.parsing.spi.support.CancelSupport;
import org.openide.util.Parameters;

/**
 *
 * @author Tomas Zezula
 */
public abstract class SpiSupportAccessor {
    private static volatile SpiSupportAccessor instance;

    @NonNull
    public static synchronized SpiSupportAccessor getInstance() {
        if (instance == null) {
            try {
                Class.forName(org.netbeans.modules.csl.spi.support.CancelSupport.class.getName(), true, SpiSupportAccessor.class.getClassLoader());
                assert instance != null;
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
        }
        return instance;
    }

    public static void setInstance(@NonNull final SpiSupportAccessor inst) {
        Parameters.notNull("inst", inst);   //NOI18N
        instance = inst;
    }
    public abstract void setCancelSupport(@NonNull CancelSupport cancelSupport);
    public abstract void removeCancelSupport(@NonNull CancelSupport cancelSupport);
}




import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.text.BadLocationException;

import org.netbeans.modules.csl.core.GsfHtmlFormatter;
import org.netbeans.modules.csl.core.Language;
import org.netbeans.modules.csl.core.LanguageRegistry;
import org.netbeans.modules.csl.core.SpiSupportAccessor;
import org.netbeans.modules.csl.navigation.ElementScanningTask;
import org.netbeans.modules.csl.spi.ParserResult;
import org.netbeans.modules.parsing.api.Embedding;

import org.netbeans.modules.parsing.spi.Scheduler;
import org.netbeans.modules.parsing.spi.SchedulerEvent;
import org.netbeans.modules.parsing.spi.SchedulerTask;
import org.netbeans.modules.parsing.spi.support.CancelSupport;
import org.openide.filesystems.FileObject;
import org.openide.text.NbDocument;
import org.openide.util.NbBundle;

 *
 * @author lahvac
 */
public final class ComputeAnnotations extends ParserResultTask<Result> {

    private static final Logger LOG = Logger.getLogger(ComputeAnnotations.class.getName());
    private final CancelSupport cancel = CancelSupport.create(this);
    
    @Override
    public void run(Result result, SchedulerEvent event) {
        if (!(result instanceof ParserResult)) {
            return;
        }
        SpiSupportAccessor.getInstance().setCancelSupport(cancel);
        try {
            final FileObject file = result.getSnapshot().getSource().getFileObject();

            if (file == null) {
                return;
            }

            final StyledDocument doc = (StyledDocument) result.getSnapshot().getSource().getDocument(false);
            return;
        }

            if (doc == null) {
                return;
            }

            final List<IsOverriddenAnnotation> annotations = new LinkedList<IsOverriddenAnnotation>();
            try {
                ParserManager.parse(Collections.singleton(result.getSnapshot().getSource()), new UserTask() {
                    public @Override void run(ResultIterator resultIterator) throws Exception {
                        Language language = LanguageRegistry.getInstance().getLanguageByMimeType(resultIterator.getSnapshot().getMimeType());
                        if(language != null) { //check for non csl results
                            StructureScanner scanner = language.getStructure();
                            OverridingMethods om = language.getOverridingMethods();
                            if (scanner != null && om != null) {
                                Parser.Result r = resultIterator.getParserResult();
                                if (r instanceof ParserResult) {
                                    Map<ElementHandle, Collection<? extends AlternativeLocation>> overriding = new HashMap<ElementHandle, Collection<? extends AlternativeLocation>>();
                                    Map<ElementHandle, Collection<? extends AlternativeLocation>> overridden = new HashMap<ElementHandle, Collection<? extends AlternativeLocation>>();
                                    Set<ElementHandle> seen = new HashSet<ElementHandle>();
                                    Map<ElementHandle, ElementHandle> node2Parent = new HashMap<ElementHandle, ElementHandle>();

                                    List<? extends StructureItem> children = ElementScanningTask.findCachedStructure(resultIterator.getSnapshot(), r);
                                    if (children == null) {
                                        long startTime = System.currentTimeMillis();
                                        children = scanner.scan((ParserResult) r);
                    Language language = LanguageRegistry.getInstance().getLanguageByMimeType(resultIterator.getSnapshot().getMimeType());
                    if(language != null) { //check for non csl results
                        StructureScanner scanner = language.getStructure();
                        OverridingMethods om = language.getOverridingMethods();
                        if (scanner != null && om != null) {
                            Parser.Result r = resultIterator.getParserResult();
                            if (r instanceof ParserResult) {
                                Map<ElementHandle, Collection<? extends AlternativeLocation>> overriding = new HashMap<ElementHandle, Collection<? extends AlternativeLocation>>();
                                Map<ElementHandle, Collection<? extends AlternativeLocation>> overridden = new HashMap<ElementHandle, Collection<? extends AlternativeLocation>>();
                                Set<ElementHandle> seen = new HashSet<ElementHandle>();
                                Map<ElementHandle, ElementHandle> node2Parent = new HashMap<ElementHandle, ElementHandle>();
                                
                                List<? extends StructureItem> children = ElementScanningTask.findCachedStructure(resultIterator.getSnapshot(), r);
                                if (children == null) {
                                    long startTime = System.currentTimeMillis();
                                    children = scanner.scan((ParserResult) r);

                                        long endTime = System.currentTimeMillis();
                                        Logger.getLogger("TIMER").log(Level.FINE, "Structure (" + language.getMimeType() + ")",
                                                new Object[]{file, endTime - startTime});
                                        ElementScanningTask.markProcessed(r, children);
                                    }
                                    List<StructureItem> todo = new LinkedList<StructureItem>(children);
                                
                                while (!todo.isEmpty()) {
                                    StructureItem i = todo.remove(0);

                                    while (!todo.isEmpty()) {
                                        StructureItem i = todo.remove(0);

                                        todo.addAll(i.getNestedItems());

                                        for (StructureItem nested : i.getNestedItems()) {
                                            if (!node2Parent.containsKey(nested.getElementHandle())) {
                                                node2Parent.put(nested.getElementHandle(), i.getElementHandle());
                                            }
                                        }

                                        if (seen.add(i.getElementHandle())) {
                                            if (i.getElementHandle().getKind() != ElementKind.CLASS && i.getElementHandle().getKind() != ElementKind.INTERFACE) {
                                                Collection<? extends AlternativeLocation> ov = om.overrides((ParserResult) r, i.getElementHandle());

                                                if (ov != null && !ov.isEmpty()) {
                                                    overriding.put(i.getElementHandle(), ov);
                                                }
                                            }

                                            if (om.isOverriddenBySupported((ParserResult) r, i.getElementHandle())) {
                                                Collection<? extends AlternativeLocation> on = om.overriddenBy((ParserResult) r, i.getElementHandle());

                                                if (on != null && !on.isEmpty()) {
                                                    overridden.put(i.getElementHandle(), on);
                                                }
                                            }
                                        }
                                    }

                                    createAnnotations((ParserResult) r, doc, overriding, node2Parent, false, annotations);
                                    createAnnotations((ParserResult) r, doc, overridden, node2Parent, true, annotations);
                                            Collection<? extends AlternativeLocation> ov = om.overrides((ParserResult) r, i.getElementHandle());

                                            if (ov != null && !ov.isEmpty()) {
                                                overriding.put(i.getElementHandle(), ov);
                                            }
                                        }

                                        if (om.isOverriddenBySupported((ParserResult) r, i.getElementHandle())) {
                                            Collection<? extends AlternativeLocation> on = om.overriddenBy((ParserResult) r, i.getElementHandle());

                                            if (on != null && !on.isEmpty()) {
                                                overridden.put(i.getElementHandle(), on);
                                            }
                                        }
                                    }
                                }

                                createAnnotations((ParserResult) r, doc, overriding, node2Parent, false, annotations);
                                createAnnotations((ParserResult) r, doc, overridden, node2Parent, true, annotations);
                            }
                        }

                        for(Embedding e : resultIterator.getEmbeddings()) {
                            run(resultIterator.getResultIterator(e));
                        }
                    }
                });
            } catch (ParseException e) {
                LOG.log(Level.WARNING, null, e);
            }

            AnnotationsHolder holder = AnnotationsHolder.get(file);

            if (holder != null) {
                holder.setNewAnnotations(annotations);
            }
//          Logger.getLogger("TIMER").log(Level.FINE, "Is Overridden Annotations", new Object[] {info.getFileObject(), end - start});
        } finally {
            SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
        }

        AnnotationsHolder holder = AnnotationsHolder.get(file);

        if (holder != null) {
            holder.setNewAnnotations(annotations);
        }
//        Logger.getLogger("TIMER").log(Level.FINE, "Is Overridden Annotations", new Object[] {info.getFileObject(), end - start});
    }

    private void createAnnotations(ParserResult r, StyledDocument doc, Map<ElementHandle, Collection<? extends AlternativeLocation>> descriptions, Map<ElementHandle, ElementHandle> node2Parent, boolean overridden, List<IsOverriddenAnnotation> annotations) {


    @Override
    public void cancel() {
        cancel.set(true);
    }

    private static Position getPosition(final StyledDocument doc, final int offset) {
        class Impl implements Runnable {
            private Position pos;





import java.awt.Color;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.SortedSet;

import org.netbeans.modules.csl.spi.ParserResult;
import org.netbeans.modules.csl.core.Language;
import org.netbeans.modules.csl.api.ColoringAttributes.Coloring;
import org.netbeans.modules.csl.core.SpiSupportAccessor;
import org.netbeans.modules.parsing.api.Snapshot;
import org.netbeans.modules.parsing.spi.CursorMovedSchedulerEvent;
import org.netbeans.modules.parsing.spi.ParserResultTask;
import org.netbeans.modules.parsing.spi.Scheduler;
import org.netbeans.modules.parsing.spi.SchedulerEvent;
import org.netbeans.modules.parsing.spi.support.CancelSupport;
import org.netbeans.spi.editor.highlighting.support.AbstractHighlightsContainer;
import org.openide.ErrorManager;
import org.openide.util.NbBundle;

 *
 * @author Jan Lahoda
 */
public final class MarkOccurrencesHighlighter extends ParserResultTask<ParserResult> {

    private static final Logger LOG = Logger.getLogger(MarkOccurrencesHighlighter.class.getName());
    
    //private FileObject file;
    private final CancelSupport cancel = CancelSupport.create(this);
    private final Language language;
    private final Snapshot snapshot;
    private int version;

//    }
//
    public void run(ParserResult info, SchedulerEvent event) {
        SpiSupportAccessor.getInstance().setCancelSupport(cancel);
        try {
            Document doc = snapshot.getSource().getDocument(false);
        
        if (doc == null) {
            LOG.log(Level.INFO, "MarkOccurencesHighlighter: Cannot get document!"); //NOI18N
            return ;
        }
        
        if (!(event instanceof CursorMovedSchedulerEvent)) {
            return;
        }

            if (doc == null) {
                LOG.log(Level.INFO, "MarkOccurencesHighlighter: Cannot get document!"); //NOI18N
                return ;
            }
        }
        
        int snapshotOffset = info.getSnapshot().getEmbeddedOffset(caretPosition);

            if (!(event instanceof CursorMovedSchedulerEvent)) {
                return;
            }
            return;
        }

            int caretPosition = ((CursorMovedSchedulerEvent) event).getCaretOffset();
        if(bag == null) {
            //the occurrences finder haven't found anything, just ignore the result
            //and keep the previous occurrences
            return ;
        }

            if (cancel.isCancelled()) {
                return;
            }
        
        GsfSemanticLayer layer = GsfSemanticLayer.getLayer(MarkOccurrencesHighlighter.class, doc);
        SortedSet seqs = new TreeSet<SequenceElement>();

            int snapshotOffset = info.getSnapshot().getEmbeddedOffset(caretPosition);

            if (snapshotOffset == -1) {
                // caret offset not part of this lang embedding, ignore, since
                // we cannot assume identifiers in different languages match.
                return;
            }

            List<OffsetRange> bag = processImpl(info, doc, caretPosition);
            if(bag == null) {
                //the occurrences finder haven't found anything, just ignore the result
                //and keep the previous occurrences
                return ;
            }

            if (cancel.isCancelled()) {
                return;
            }

            GsfSemanticLayer layer = GsfSemanticLayer.getLayer(MarkOccurrencesHighlighter.class, doc);
            SortedSet seqs = new TreeSet<SequenceElement>();

            if (bag.size() > 0) {
                for (OffsetRange range : bag) {
                    if (range != OffsetRange.NONE) {
                        SequenceElement s = new SequenceElement(language, range, MO);
                        seqs.add(s);
                    }
                }
            }

            layer.setColorings(seqs, version++);

            OccurrencesMarkProvider.get(doc).setOccurrences(OccurrencesMarkProvider.createMarks(doc, bag, ES_COLOR, NbBundle.getMessage(MarkOccurrencesHighlighter.class, "LBL_ES_TOOLTIP")));
        } finally {
            SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
        }
        
        layer.setColorings(seqs, version++);
        
        OccurrencesMarkProvider.get(doc).setOccurrences(OccurrencesMarkProvider.createMarks(doc, bag, ES_COLOR, NbBundle.getMessage(MarkOccurrencesHighlighter.class, "LBL_ES_TOOLTIP")));
    }
    
    @NonNull

            ErrorManager.getDefault().notify(ex);
        }

        if (cancel.isCancelled()) {
            finder.cancel();
        }


    public Class<? extends Scheduler> getSchedulerClass () {
        return Scheduler.CURSOR_SENSITIVE_TASK_SCHEDULER;
    }

    @Override
    public final void cancel() {
    public final synchronized void cancel() {
        canceled = true;
    }

    protected final synchronized boolean isCancelled() {
        return canceled;
    }
    
    protected final synchronized void resume() {
        canceled = false;
    }
    
    public static AbstractHighlightsContainer getHighlightsBag(Document doc) {
        GsfSemanticLayer highlight = GsfSemanticLayer.getLayer(MarkOccurrencesHighlighter.class, doc);
        return highlight;

Lines 58-63 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/editor/semantic/SemanticHighlighter.java (-58 / +54 lines)
58	import org.netbeans.modules.csl.api.SemanticAnalyzer;	58	import org.netbeans.modules.csl.api.SemanticAnalyzer;
59	import org.netbeans.modules.csl.core.Language;	59	import org.netbeans.modules.csl.core.Language;
60	import org.netbeans.modules.csl.core.LanguageRegistry;	60	import org.netbeans.modules.csl.core.LanguageRegistry;
		61	import org.netbeans.modules.csl.core.SpiSupportAccessor;
61	import org.netbeans.modules.csl.spi.ParserResult;	62	import org.netbeans.modules.csl.spi.ParserResult;
62	import org.netbeans.modules.parsing.api.Embedding;	63	import org.netbeans.modules.parsing.api.Embedding;
63	import org.netbeans.modules.parsing.api.ParserManager;	64	import org.netbeans.modules.parsing.api.ParserManager;
Lines 65-70 Link Here
65	import org.netbeans.modules.parsing.api.Source;	66	import org.netbeans.modules.parsing.api.Source;
66	import org.netbeans.modules.parsing.api.UserTask;	67	import org.netbeans.modules.parsing.api.UserTask;
67	import org.netbeans.modules.parsing.spi.*;	68	import org.netbeans.modules.parsing.spi.*;
		69	import org.netbeans.modules.parsing.spi.support.CancelSupport;
68		70
69		71
70	/**	72	/**
Lines 76-84 Link Here
76	*	78	*
77	* @author Jan Lahoda	79	* @author Jan Lahoda
78	*/	80	*/
79	public class SemanticHighlighter extends IndexingAwareParserResultTask<ParserResult> {	81	public final class SemanticHighlighter extends IndexingAwareParserResultTask<ParserResult> {
80		82
81	private static final Logger LOG = Logger.getLogger(SemanticHighlighter.class.getName());	83	private static final Logger LOG = Logger.getLogger(SemanticHighlighter.class.getName());
		84
		85	private final CancelSupport cancel = CancelSupport.create(this);
82		86
83	/** Creates a new instance of SemanticHighlighter */	87	/** Creates a new instance of SemanticHighlighter */
84	SemanticHighlighter() {	88	SemanticHighlighter() {
Lines 99-175 Link Here
99	return Scheduler.EDITOR_SENSITIVE_TASK_SCHEDULER;	103	return Scheduler.EDITOR_SENSITIVE_TASK_SCHEDULER;
100	}	104	}
101		105
102	private boolean cancelled;
103		106
104	public final synchronized void cancel() {	107	public final void cancel() {
105	cancelled = true;
106	}
107
108	protected final synchronized boolean isCancelled() {
109	return cancelled;
110	}
111
112	protected final synchronized void resume() {
113	cancelled = false;
114	}	108	}
115		109
116	public @Override void run(ParserResult info, SchedulerEvent event) {	110	public @Override void run(ParserResult info, SchedulerEvent event) {
117	resume();
118
119	Document doc = info.getSnapshot().getSource().getDocument(false);	111	Document doc = info.getSnapshot().getSource().getDocument(false);
120	if (doc == null) {	112	if (doc == null) {
121	return;	113	return;
122	}	114	}
		115	SpiSupportAccessor.getInstance().setCancelSupport(cancel);
		116	try {
		117	long startTime = System.currentTimeMillis();
123		118
124	long startTime = System.currentTimeMillis();	119	Source source = info.getSnapshot().getSource();
		120	final SortedSet<SequenceElement> newColoring = new TreeSet<SequenceElement>();
		121	try {
		122	ParserManager.parse(Collections.singleton(source), new UserTask() {
		123	public @Override void run(ResultIterator resultIterator) throws Exception {
		124	String mimeType = resultIterator.getSnapshot().getMimeType();
		125	Language language = LanguageRegistry.getInstance().getLanguageByMimeType(mimeType);
		126	if (language != null) {
		127	ColoringManager manager = language.getColoringManager();
		128	SemanticAnalyzer task = language.getSemanticAnalyzer();
		129	if (manager != null && task != null) {
		130	Parser.Result r = resultIterator.getParserResult();
		131	if (r instanceof ParserResult) {
		132	process(language, (ParserResult) r, newColoring);
		133	}
		134	}
		135	}
125		136
126	Source source = info.getSnapshot().getSource();	137	for(Embedding e : resultIterator.getEmbeddings()) {
127	final SortedSet<SequenceElement> newColoring = new TreeSet<SequenceElement>();	138	if (cancel.isCancelled()) {
128	try {	139	return;
129	ParserManager.parse(Collections.singleton(source), new UserTask() {	140	} else {
130	public @Override void run(ResultIterator resultIterator) throws Exception {	141	run(resultIterator.getResultIterator(e));
131	String mimeType = resultIterator.getSnapshot().getMimeType();
132	Language language = LanguageRegistry.getInstance().getLanguageByMimeType(mimeType);
133	if (language != null) {
134	ColoringManager manager = language.getColoringManager();
135	SemanticAnalyzer task = language.getSemanticAnalyzer();
136	if (manager != null && task != null) {
137	Parser.Result r = resultIterator.getParserResult();
138	if (r instanceof ParserResult) {
139	process(language, (ParserResult) r, newColoring);
140	}	142	}
141	}	143	}
142	}	144	}
		145	});
		146	} catch (ParseException e) {
		147	LOG.log(Level.WARNING, null, e);
		148	return;
		149	}
143		150
144	for(Embedding e : resultIterator.getEmbeddings()) {	151	long endTime = System.currentTimeMillis();
145	if (isCancelled()) {	152	Logger.getLogger("TIMER").log(Level.FINE, "Semantic (" + source.getMimeType() + ")", //NOI18N
146	return;	153	new Object[] { source.getFileObject(), endTime - startTime});
147	} else {	154
148	run(resultIterator.getResultIterator(e));	155	if (cancel.isCancelled()) {
149	}	156	return;
150	}	157	}
		158
		159	final GsfSemanticLayer layer = GsfSemanticLayer.getLayer(SemanticHighlighter.class, doc);
		160	SwingUtilities.invokeLater(new Runnable () {
		161	public void run() {
		162	// XXX: parsingapi
		163	layer.setColorings(newColoring, -1); //version
151	}	164	}
152	});	165	});
153	} catch (ParseException e) {	166	} finally {
154	LOG.log(Level.WARNING, null, e);	167	SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
155	return;
156	}	168	}
157
158	long endTime = System.currentTimeMillis();
159	Logger.getLogger("TIMER").log(Level.FINE, "Semantic (" + source.getMimeType() + ")", //NOI18N
160	new Object[] { source.getFileObject(), endTime - startTime});
161
162	if (isCancelled()) {
163	return;
164	}
165
166	final GsfSemanticLayer layer = GsfSemanticLayer.getLayer(SemanticHighlighter.class, doc);
167	SwingUtilities.invokeLater(new Runnable () {
168	public void run() {
169	// XXX: parsingapi
170	layer.setColorings(newColoring, -1); //version
171	}
172	});
173	}	169	}
174		170
175		171
Lines 294-300 Link Here
294	// }	290	// }
295		291
296		292
297	if (isCancelled()) {	293	if (cancel.isCancelled()) {
298	return;	294	return;
299	}	295	}
300		296
Lines 312-318 Link Here
312	"(mimepath = " + result.getSnapshot().getMimePath() + ")", ex);	308	"(mimepath = " + result.getSnapshot().getMimePath() + ")", ex);
313	}	309	}
314		310
315	if (isCancelled()) {	311	if (cancel.isCancelled()) {
316	task.cancel();	312	task.cancel();
317	return;	313	return;
318	}	314	}
Lines 330-336 Link Here
330		326
331	newColoring.add(new SequenceElement(language, range, c));	327	newColoring.add(new SequenceElement(language, range, c));
332		328
333	if (isCancelled()) {	329	if (cancel.isCancelled()) {
334	return;	330	return;
335	}	331	}
336	}	332	}




import org.netbeans.modules.csl.api.Hint;
import org.netbeans.modules.csl.api.OffsetRange;
import org.netbeans.modules.csl.api.RuleContext;
import org.netbeans.modules.csl.core.SpiSupportAccessor;
import org.netbeans.modules.csl.hints.infrastructure.GsfHintsManager;
import org.netbeans.modules.csl.spi.ParserResult;
import org.netbeans.modules.parsing.api.Embedding;

import org.netbeans.modules.parsing.spi.ParseException;
import org.netbeans.modules.parsing.spi.ParserResultTask;
import org.netbeans.modules.parsing.spi.SchedulerEvent;
import org.netbeans.modules.parsing.spi.support.CancelSupport;
import org.netbeans.spi.editor.hints.ErrorDescription;
import org.netbeans.spi.editor.hints.ErrorDescriptionFactory;
import org.netbeans.spi.editor.hints.HintsController;

public final class GsfHintsProvider extends ParserResultTask<ParserResult> {
    
    public static final Logger LOG = Logger.getLogger(GsfHintsProvider.class.getName()); // NOI18N

    private final CancelSupport cancel = CancelSupport.create(this);
    private FileObject file;
    
    /**

        }
        
        for (Error d : errors) {
            if (cancel.isCancelled()) {
                return null;
            }
            

            final String desc = d.getDisplayName();
            final Position[] range = getLine(d, doc, position, endPosition);
            
            if (cancel.isCancelled()) {
                return null;
            }
            

            descs.add(ErrorDescriptionFactory.createErrorDescription(errorKind2Severity.get(d.getSeverity()), desc, ehm, doc, range[0], range[1]));
        }
        
        if (cancel.isCancelled()) {
            return null;
        }
        

        // under the document read-lock.
        doc.render(new Runnable() {
            public void run() {
                if (cancel.isCancelled()) {
                    return;
                }
                ret[0] = getLine0(d, doc, startOffset, endOffset);

        int len = doc.getLength();

        if (startOffsetFinal > len || endOffsetFinal > len) {
            if (!cancel.isCancelled() && LOG.isLoggable(Level.WARNING)) {
                LOG.log(Level.WARNING, "document changed, but not canceled?" );
                LOG.log(Level.WARNING, "len = " + len );
                LOG.log(Level.WARNING, "startOffset = " + startOffsetFinal );

        
        return result;
    }


    
    synchronized boolean isCanceled() {
        return cancel;
    }
    
    @Override
    public void cancel() {
        final HintsProvider curProvider = this.pendingProvider;
        synchronized (this) {
            curProvider = this.pendingProvider;
            cancel = true;
        }
        if (curProvider != null) {
            curProvider.cancel();
        }
    }

    synchronized void resume() {
        cancel = false;
    }
    
    private List<Error> processProviderErrors(
            final List<ErrorDescription> descriptions, 
            Snapshot topLevelSnapshot, final ParserResult r, final Language language) throws ParseException {

        try {
            synchronized (this) {
                pendingProvider = provider;
                if (cancel.isCancelled()) {
                    return errors;
                }
            }

        
        for(Embedding e : resultIterator.getEmbeddings()) {
            try {
                if (cancel.isCancelled()) {
                    return;
                }
            } catch (Exception ex) {

    }
    
    public @Override void run(ParserResult result, SchedulerEvent event) {
        resume();
        
        final Document doc = getDocument();
        
        if (doc == null) {
            LOG.log(Level.INFO, "SemanticHighlighter: Cannot get document!");
            return ;
        }
        SpiSupportAccessor.getInstance().setCancelSupport(cancel);
        try {
            ParserManager.parse(Collections.singleton(result.getSnapshot().getSource()), new UserTask() {
                public @Override void run(ResultIterator resultIterator) throws ParseException {

            });
        } catch (ParseException e) {
            LOG.log(Level.WARNING, null, e);
        } finally {
            SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
        }
    }
    




import org.netbeans.modules.csl.core.LanguageRegistry;
import org.netbeans.modules.csl.api.Hint;
import org.netbeans.modules.csl.api.RuleContext;
import org.netbeans.modules.csl.core.SpiSupportAccessor;
import org.netbeans.modules.csl.spi.ParserResult;
import org.netbeans.modules.parsing.api.Embedding;
import org.netbeans.modules.parsing.api.ParserManager;

import org.netbeans.modules.parsing.spi.ParserResultTask;
import org.netbeans.modules.parsing.spi.Scheduler;
import org.netbeans.modules.parsing.spi.SchedulerEvent;
import org.netbeans.modules.parsing.spi.support.CancelSupport;
import org.netbeans.spi.editor.hints.ErrorDescription;
import org.netbeans.spi.editor.hints.HintsController;


 * 
 * @author Tor Norbye
 */
public final class HintsTask extends ParserResultTask<ParserResult> {

    private static final Logger LOG = Logger.getLogger(HintsTask.class.getName());
    private final CancelSupport cancel = CancelSupport.create(this);

    /**
     * Tracks the HintsProvider being executed, so it can be cancelled.
     */

    }
    
    public @Override void run(ParserResult result, SchedulerEvent event) {
        final List<ErrorDescription> descriptions = new ArrayList<>();
        SpiSupportAccessor.getInstance().setCancelSupport(cancel);
        final List<ErrorDescription> descriptions = new ArrayList<ErrorDescription>();

        try {
            ParserManager.parse(Collections.singleton(result.getSnapshot().getSource()), new UserTask() {
                public @Override void run(ResultIterator resultIterator) throws ParseException {

                    try {
                        synchronized (HintsTask.this) {
                            pendingProvider = provider;
                            if (cancel.isCancelled()) {
                                return;
                            }
                        }

                        pendingProvider = null;
                    }

                    if (cancel.isCancelled()) {
                        return;
                    }


            });
        } catch (ParseException e) {
            LOG.log(Level.WARNING, null, e);
        } finally {
            SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
        }

        HintsController.setErrors(result.getSnapshot().getSource().getFileObject(), HintsTask.class.getName(), descriptions);
    }


    }

    public @Override void cancel() {
        final HintsProvider proc = pendingProvider;
        synchronized  (this) {
            proc = pendingProvider;
            cancelled = true;
        }
        if (proc != null) {
            proc.cancel();
        }
    }

    private synchronized void resume() {
        cancelled = false;
    }

    private synchronized boolean isCancelled() {
        return cancelled;
    }
}




import org.netbeans.modules.csl.api.HintsProvider;
import org.netbeans.modules.csl.api.RuleContext;
import org.netbeans.modules.csl.core.LanguageRegistry;
import org.netbeans.modules.csl.core.SpiSupportAccessor;
import org.netbeans.modules.parsing.api.ResultIterator;
import org.netbeans.modules.parsing.spi.Parser;
import org.netbeans.modules.parsing.spi.Scheduler;

import org.netbeans.modules.parsing.spi.ParseException;
import org.netbeans.modules.parsing.spi.ParserResultTask;
import org.netbeans.modules.parsing.spi.SchedulerEvent;
import org.netbeans.modules.parsing.spi.support.CancelSupport;
import org.netbeans.spi.editor.hints.ErrorDescription;
import org.netbeans.spi.editor.hints.HintsController;
import org.openide.filesystems.FileObject;

 *
 * @author Tor Norbye
 */
public final class SelectionHintsTask extends ParserResultTask<ParserResult> {
    
    private static final Logger LOG = Logger.getLogger(SelectionHintsTask.class.getName());
    private final CancelSupport cancel = CancelSupport.create(this);
    
    /**
     * Tracks the HintsProvider being executed, so it can be cancelled.

    }
    
    public @Override void run(ParserResult result, SchedulerEvent event) {
        resume();

        final FileObject fileObject = result.getSnapshot().getSource().getFileObject();
        if (fileObject == null || cancel.isCancelled()) {
            return;
        }

        if (!(event instanceof CursorMovedSchedulerEvent) || cancel.isCancelled()) {
            return;
        }

        SpiSupportAccessor.getInstance().setCancelSupport(cancel);
        try {
            // Do we have a selection? If so, don't do suggestions
            CursorMovedSchedulerEvent evt = (CursorMovedSchedulerEvent) event;
            final int[] range = new int [] {
                Math.min(evt.getMarkOffset(), evt.getCaretOffset()),
                Math.max(evt.getMarkOffset(), evt.getCaretOffset())
            };
            if (range == null || range.length != 2 || range[0] == -1 || range[1] == -1 || range[0] == range[1]) {
                HintsController.setErrors(fileObject, SelectionHintsTask.class.getName(), Collections.<ErrorDescription>emptyList());
                return;
            }

            try {
                ParserManager.parse(Collections.singleton(result.getSnapshot().getSource()), new UserTask() {
                    public @Override void run(ResultIterator resultIterator) throws Exception {
                        Parser.Result r = resultIterator.getParserResult(range[0]);
                        if(!(r instanceof ParserResult)) {
                            return ;
                        }
                        Language language = LanguageRegistry.getInstance().getLanguageByMimeType(r.getSnapshot().getMimeType());
                        if (language == null || cancel.isCancelled()) {
                            return;
                        }

                        HintsProvider provider = language.getHintsProvider();
                        if (provider == null || cancel.isCancelled()) {
                            return;
                        }

                        GsfHintsManager manager = language.getHintsManager();
                        if (manager == null || cancel.isCancelled()) {
                            return;
                        }

                        List<ErrorDescription> description = new ArrayList<ErrorDescription>();
                        List<Hint> hints = new ArrayList<Hint>();

                        RuleContext ruleContext = manager.createRuleContext((ParserResult) r, language, -1, range[0], range[1]);
                        if (ruleContext != null) {
                            try {
                                synchronized (this) {
                                    pendingProvider = provider;
                                    if (cancel.isCancelled()) {
                                        return;
                                    }
                                }
                                provider.computeSelectionHints(manager, ruleContext, hints, range[0], range[1]);
                            } finally {
                                pendingProvider = null;
                            }

                            for (int i = 0; i < hints.size(); i++) {
                                Hint hint= hints.get(i);

                                if (cancel.isCancelled()) {
                                    return;
                                }

                                ErrorDescription desc = manager.createDescription(hint, ruleContext, false, i == hints.size()-1);
                                description.add(desc);
                            }
                            provider.computeSelectionHints(manager, ruleContext, hints, range[0], range[1]);
                        } finally {
                            pendingProvider = null;
                        }

                        if (cancel.isCancelled()) {
                            return;
                        }

                        HintsController.setErrors(fileObject, SelectionHintsTask.class.getName(), description);
                                return;
                            }
                            
                            ErrorDescription desc = manager.createDescription(hint, ruleContext, false, i == hints.size()-1);
                            description.add(desc);
                        }
                    }
                });
            } catch (ParseException e) {
                LOG.log(Level.WARNING, null, e);
            }
        } finally {
            SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
                }
            });
        } catch (ParseException e) {
            LOG.log(Level.WARNING, null, e);
        }
    }


    }

    public @Override void cancel() {
        final HintsProvider p = pendingProvider;
            cancelled = true;
        }
        HintsProvider p = pendingProvider;
        if (p != null) {
            p.cancel();
        }
    }

    private synchronized void resume() {
        cancelled = false;
    }

    private synchronized boolean isCancelled() {
        return cancelled;
    }
}




import org.netbeans.modules.csl.api.Hint;
import org.netbeans.modules.csl.api.OffsetRange;
import org.netbeans.modules.csl.api.RuleContext;
import org.netbeans.modules.csl.core.SpiSupportAccessor;
import org.netbeans.modules.csl.spi.ParserResult;
import org.netbeans.modules.parsing.api.ParserManager;
import org.netbeans.modules.parsing.api.ResultIterator;

import org.netbeans.modules.parsing.spi.ParserResultTask;
import org.netbeans.modules.parsing.spi.Scheduler;
import org.netbeans.modules.parsing.spi.SchedulerEvent;
import org.netbeans.modules.parsing.spi.support.CancelSupport;
import org.netbeans.spi.editor.hints.ErrorDescription;
import org.netbeans.spi.editor.hints.HintsController;
import org.openide.filesystems.FileObject;

 * 
 * @author Tor Norbye
 */
public final class SuggestionsTask extends ParserResultTask<ParserResult> {
    
    private static final Logger LOG = Logger.getLogger(SuggestionsTask.class.getName());
    private final CancelSupport cancel = CancelSupport.create(this);

    /**
     * Tracks the HintsProvider being executed, so it can be cancelled.

    }
    
    public @Override void run(ParserResult result, SchedulerEvent event) {

        
        final FileObject fileObject = result.getSnapshot().getSource().getFileObject();
        if (fileObject == null || cancel.isCancelled()) {
            return;
        }

        if (!(event instanceof CursorMovedSchedulerEvent) || cancel.isCancelled()) {
            return;
        }

        SpiSupportAccessor.getInstance().setCancelSupport(cancel);
        try {
            // Do we have a selection? If so, don't do suggestions
            CursorMovedSchedulerEvent evt = (CursorMovedSchedulerEvent) event;
            int[] range = new int [] {
                Math.min(evt.getMarkOffset(), evt.getCaretOffset()),
                Math.max(evt.getMarkOffset(), evt.getCaretOffset())
            };
            if (range != null && range.length == 2 && range[0] != -1 && range[1] != -1 && range[0] != range[1]) {
                HintsController.setErrors(fileObject, SuggestionsTask.class.getName(), Collections.<ErrorDescription>emptyList());
                return;
            }

            final int pos = evt.getCaretOffset();
            if (pos == -1 || cancel.isCancelled()) {
                return;
            }
        
        try {
            ParserManager.parse(Collections.singleton(result.getSnapshot().getSource()), new UserTask() {
                public @Override void run(ResultIterator resultIterator) throws Exception {
                    Parser.Result r = resultIterator.getParserResult(pos);
                    if(!(r instanceof ParserResult)) {
                        return ;
                    }
                    Language language = LanguageRegistry.getInstance().getLanguageByMimeType(r.getSnapshot().getMimeType());
                    if (language == null || isCancelled()) {
                        return;
                    }

            try {
                ParserManager.parse(Collections.singleton(result.getSnapshot().getSource()), new UserTask() {
                    public @Override void run(ResultIterator resultIterator) throws Exception {
                        Parser.Result r = resultIterator.getParserResult(pos);
                        if(!(r instanceof ParserResult)) {
                            return ;
                        }
                        Language language = LanguageRegistry.getInstance().getLanguageByMimeType(r.getSnapshot().getMimeType());
                        if (language == null || cancel.isCancelled()) {
                            return;
                        }
                    }
                    List<ErrorDescription> descriptions = new ArrayList<ErrorDescription>();
                    List<Hint> hints = new ArrayList<Hint>();

                        HintsProvider provider = language.getHintsProvider();
                        if (provider == null || cancel.isCancelled()) {
                            return;
                        }
                        GsfHintsManager manager = language.getHintsManager();
                        if (manager == null || cancel.isCancelled()) {
                            return;
                        }
                        RuleContext ruleContext = manager.createRuleContext((ParserResult) r, language, pos, -1, -1);
                        if (ruleContext == null || cancel.isCancelled()) {
                            return;
                        }
                        List<ErrorDescription> descriptions = new ArrayList<ErrorDescription>();
                        List<Hint> hints = new ArrayList<Hint>();

                        OffsetRange linerange = findLineBoundaries(resultIterator.getSnapshot().getText(), pos);
                        try {
                            synchronized (this) {
                                pendingProvider = provider;
                                if (cancel.isCancelled()) {
                                    return;
                                }
                            }
                            provider.computeSuggestions(manager, ruleContext, hints, pos);
                        } finally {
                            pendingProvider = null;
                        }

                        for (int i = 0; i < hints.size(); i++) {
                            Hint hint = hints.get(i);
                            if (cancel.isCancelled()) {
                                return;
                            }
                            // #224654 - suggestions may be returned for text unrelated to caret position
                            if (linerange != OffsetRange.NONE && !overlaps(linerange, hint.getRange())) {
                                continue;
                            }
                            ErrorDescription desc = manager.createDescription(hint, ruleContext, false, i == hints.size()-1);
                            descriptions.add(desc);
                        }
                        provider.computeSuggestions(manager, ruleContext, hints, pos);                        
                    } finally {
                        pendingProvider = null;
                    }

                        if (cancel.isCancelled()) {
                        Hint hint = hints.get(i);
                        if (isCancelled()) {
                            return;
                        }

                        HintsController.setErrors(r.getSnapshot().getSource().getFileObject(), SuggestionsTask.class.getName(), descriptions);
                            continue;
                        }
                        ErrorDescription desc = manager.createDescription(hint, ruleContext, false, i == hints.size()-1);
                        descriptions.add(desc);
                    }
                });
            } catch (ParseException e) {
                LOG.log(Level.WARNING, null, e);
            }
        } finally {
            SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
                }
            });
        } catch (ParseException e) {
            LOG.log(Level.WARNING, null, e);
        }
    }
    

    }

    public @Override void cancel() {
        final HintsProvider p = pendingProvider;
            cancelled = true;
        }
        HintsProvider p = pendingProvider;
        if (p != null) {
            p.cancel();
        }
    }

    private synchronized void resume() {
        cancelled = false;
    }

    private synchronized boolean isCancelled() {
        return cancelled;
    }
}




 */
public class BreadCrumbsTask extends ElementScanningTask {

    public BreadCrumbsTask() {
    }

    private static final RequestProcessor WORKER = new RequestProcessor(BreadCrumbsTask.class.getName(), 1, false, false);
    
    @Override

    private final AtomicLong requestId = new AtomicLong();
    
    @Override
    public void run(final ParserResult result, final SchedulerEvent event) {
        runWithCancelService(new Runnable() {
            @Override
            public void run() {
                resume();
                final long id = requestId.incrementAndGet();

                final Document doc = result.getSnapshot().getSource().getDocument(false);

                if (doc == null || !BreadcrumbsController.areBreadCrumsEnabled(doc)) return ;

                final int caret;

                if (event instanceof CursorMovedSchedulerEvent) {
                    caret = ((CursorMovedSchedulerEvent) event).getCaretOffset();
                } else {
                    //XXX: outside AWT!
                    JTextComponent c = EditorRegistry.focusedComponent();

                    if (c != null && c.getDocument() == doc)
                        caret = c.getCaretPosition();
                    else
                        caret = (-1);
                }

                if (caret == (-1)) return ;

                final StructureItem structureRoot = computeStructureRoot(result.getSnapshot().getSource());

                if (structureRoot == null) return ;

                WORKER.post(new Runnable() {
                    @Override public void run() {
                        selectNode(doc, structureRoot, id, caret);
                    }
                });
            }
        });
    }





package org.netbeans.modules.csl.navigation;

import org.netbeans.modules.csl.core.SpiSupportAccessor;
import org.netbeans.modules.csl.spi.ParserResult;
import org.netbeans.modules.parsing.spi.*;
import org.netbeans.modules.parsing.spi.support.CancelSupport;

/**
 * This file is originally from Retouche, the Java Support

 * This task is called every time the caret position changes in a GSF editor.
 * It delegates to the navigator to show the current selection.
 */
public final class CaretListeningTask extends IndexingAwareParserResultTask<ParserResult> {
    
    private final CancelSupport cancel = CancelSupport.create(this);
    
    CaretListeningTask() {
        super(TaskIndexingMode.ALLOWED_DURING_SCAN);
    }
    
    public @Override void run(ParserResult result, SchedulerEvent event) {

        
        boolean navigatorShouldUpdate = ClassMemberPanel.getInstance() != null; // XXX set by navigator visible
        if (cancel.isCancelled() || (!navigatorShouldUpdate) || !(event instanceof CursorMovedSchedulerEvent)) {
        if (isCancelled() || (!navigatorShouldUpdate) || !(event instanceof CursorMovedSchedulerEvent)) {
            return;
        }

        SpiSupportAccessor.getInstance().setCancelSupport(cancel);
        try {
            int offset = ((CursorMovedSchedulerEvent) event).getCaretOffset();
            if (offset != -1) {
                ClassMemberPanel.getInstance().selectElement(result, offset);
            }
        } finally {
            SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
        }
    }


    @Override
     * method immediately.
     */
    public final synchronized void cancel() {
        canceled = true;
    }
    
    protected final synchronized boolean isCancelled() {
        return canceled;
    }
    
    protected final synchronized void resume() {
        canceled = false;
    }

    public @Override int getPriority() {




import java.util.Collections;
import org.netbeans.modules.csl.core.AbstractTaskFactory;
import org.netbeans.modules.csl.core.Language;
import org.netbeans.modules.csl.core.SpiSupportAccessor;
import org.netbeans.modules.parsing.api.Snapshot;
import org.netbeans.modules.parsing.spi.Scheduler;
import org.netbeans.modules.parsing.spi.SchedulerTask;
import org.openide.util.Lookup;
import org.netbeans.modules.csl.spi.ParserResult;
import org.netbeans.modules.parsing.spi.*;
import org.netbeans.modules.parsing.spi.support.CancelSupport;

/**
 * This file is originally from Retouche, the Java Support 

    }

    private final class ProxyElementScanningTask extends IndexingAwareParserResultTask<ParserResult> {
        private final CancelSupport cancel = CancelSupport.create(this);
        private ElementScanningTask task = null;
        private Class<? extends Scheduler> clazz;


        }

        public @Override void cancel() {
            final ElementScanningTask t = getTask();
            if (t != null) {
                t.cancel();
            }
        }

        @Override
        public void run(ParserResult result, SchedulerEvent event) {
            SpiSupportAccessor.getInstance().setCancelSupport(cancel);
            try {
                final ElementScanningTask t = getTask();
                if (t != null) {
                    t.run(result, event);
                }
            } finally {
                SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
            }
        }


Lines 220-236 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/navigation/ClassMemberPanelUI.java (-10 / +14 lines)
220	public @Override Class<? extends Scheduler> getSchedulerClass() {	220	public @Override Class<? extends Scheduler> getSchedulerClass() {
221	return CSLNavigatorScheduler.class;	221	return CSLNavigatorScheduler.class;
222	}	222	}
223	@Override public void run(ParserResult result, SchedulerEvent event) {	223	@Override public void run(final ParserResult result, final SchedulerEvent event) {
224	resume();	224	runWithCancelService(new Runnable() {
225		225	@Override
226	StructureItem root = computeStructureRoot(result.getSnapshot().getSource());	226	public void run() {
227	FileObject file = result.getSnapshot().getSource().getFileObject();	227	resume();
		228	StructureItem root = computeStructureRoot(result.getSnapshot().getSource());
		229	FileObject file = result.getSnapshot().getSource().getFileObject();
228		230
229	if (root != null && file != null) {	231	if (root != null && file != null) {
230	Document doc = result.getSnapshot().getSource().getDocument(false);	232	Document doc = result.getSnapshot().getSource().getDocument(false);
231	BaseDocument bd = doc instanceof BaseDocument ? (BaseDocument)doc : null;	233	BaseDocument bd = doc instanceof BaseDocument ? (BaseDocument)doc : null;
232	refresh(root, file, bd);	234	refresh(root, file, bd);
233	}	235	}
		236	}
		237	});
234	}	238	}
235	};	239	};
236		240




import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.modules.csl.api.StructureScanner;
import org.netbeans.modules.csl.api.ElementHandle;

import org.netbeans.modules.csl.core.Language;
import org.netbeans.modules.csl.core.LanguageRegistry;
import org.netbeans.modules.csl.api.HtmlFormatter;
import org.netbeans.modules.csl.core.SpiSupportAccessor;
import org.netbeans.modules.csl.navigation.ElementNode.Description;
import org.netbeans.modules.csl.spi.ParserResult;
import org.netbeans.modules.parsing.api.Embedding;

import org.netbeans.modules.parsing.api.UserTask;
import org.netbeans.modules.parsing.spi.*;
import org.netbeans.modules.parsing.spi.Parser.Result;
import org.netbeans.modules.parsing.spi.support.CancelSupport;
import org.openide.filesystems.FileObject;
import org.openide.util.ImageUtilities;
import org.openide.util.RequestProcessor;

public abstract class ElementScanningTask extends IndexingAwareParserResultTask<ParserResult> {

    private static final Logger LOG = Logger.getLogger(ElementScanningTask.class.getName());

    private final CancelSupport cs = CancelSupport.create(this);
    private volatile boolean canceled;
    
    /**
     * Reference to the last result of parsing processed into structure.
     */
    private static final Map<Snapshot, Reference<ResultStructure>> lastResults = new WeakHashMap<>();
            new WeakHashMap<Snapshot, Reference<ResultStructure>>();

    /**
     * Cache the parser result and the resulting structure.

        return new RootStructureItem(items);
    }

    @Override
    public void cancel() {
        canceled = true;
    }

    protected final void resume() {
        canceled = false;
    }

    protected final boolean isCancelled() {
        return canceled;
    }

    protected final void runWithCancelService(@NonNull final Runnable r) {
        SpiSupportAccessor.getInstance().setCancelSupport(cs);
        try {

        } finally {
            SpiSupportAccessor.getInstance().removeCancelSupport(cs);
        }
    }
    private static final class RootStructureItem implements StructureItem {

        private final List<? extends StructureItem> items;




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2015 Sun Microsystems, Inc.
 */
package org.netbeans.modules.csl.spi.support;

import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.modules.csl.core.SpiSupportAccessor;
import org.netbeans.modules.parsing.spi.SchedulerTask;
import org.openide.util.Parameters;

/**
 * Provides a thread safe testing of the {@link SchedulerTask} canceling.
 * Provides a thread safe testing of the {@link SchedulerTask} canceling for CSL
 * services which are not implemented using {@link SchedulerTask}. For {@link SchedulerTask}
 * subclasses use parsing api {@link org.netbeans.modules.parsing.spi.support.CancelSupport}
 * @author Tomas Zezula
 * @since 2.50
 */
public final class CancelSupport {

    private static final CancelSupport INSTANCE = new CancelSupport();

    static {
        SpiSupportAccessor.setInstance(new SpiSupportAccessorImpl());
    }

    private final ThreadLocal<org.netbeans.modules.parsing.spi.support.CancelSupport> selfSpi;

    private CancelSupport() {
        this.selfSpi = new ThreadLocal<>();
    }

    /**
     * Returns true if the task is canceled.
     * @return true when task is canceled
     */
    public boolean isCancelled() {
        final org.netbeans.modules.parsing.spi.support.CancelSupport spi = selfSpi.get();
        return spi == null ?
                false :
                spi.isCancelled();
    }

    /**
     * Returns the {@link CancelSupport} instance.
     * @return the {@link CancelSupport} instance.
     */
    @NonNull
    public static CancelSupport getDefault() {
        return INSTANCE;
    }

    private static final class SpiSupportAccessorImpl extends SpiSupportAccessor {

        @Override
        public void setCancelSupport(@NonNull final org.netbeans.modules.parsing.spi.support.CancelSupport cancelSupport) {
            Parameters.notNull("cancelSupport", cancelSupport); //NOI18N
            final CancelSupport cs = getDefault();
            if (cs.selfSpi.get() == null) {
                cs.selfSpi.set(cancelSupport);
            }
        }

        @Override
        public void removeCancelSupport(@NonNull final org.netbeans.modules.parsing.spi.support.CancelSupport cancelSupport) {
            Parameters.notNull("cancelSupport", cancelSupport); //NOI18N
            final CancelSupport cs = getDefault();
            if (cs.selfSpi.get() == cancelSupport) {
                cs.selfSpi.remove();
            }
        }
    }
}

Return to bug 241009

Line 0 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/core/SpiSupportAccessor.java (+74 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2015 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2015 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.csl.core;
		43
		44	import org.netbeans.api.annotations.common.NonNull;
		45	import org.netbeans.modules.parsing.spi.support.CancelSupport;
		46	import org.openide.util.Parameters;
		47
		48	/**
		49	*
		50	* @author Tomas Zezula
		51	*/
		52	public abstract class SpiSupportAccessor {
		53	private static volatile SpiSupportAccessor instance;
		54
		55	@NonNull
		56	public static synchronized SpiSupportAccessor getInstance() {
		57	if (instance == null) {
		58	try {
		59	Class.forName(org.netbeans.modules.csl.spi.support.CancelSupport.class.getName(), true, SpiSupportAccessor.class.getClassLoader());
		60	assert instance != null;
		61	} catch (ClassNotFoundException e) {
		62	throw new RuntimeException(e);
		63	}
		64	}
65	return instance;
66	}
67
68	public static void setInstance(@NonNull final SpiSupportAccessor inst) {
69	Parameters.notNull("inst", inst); //NOI18N
70	instance = inst;
71	}
72	public abstract void setCancelSupport(@NonNull CancelSupport cancelSupport);
73	public abstract void removeCancelSupport(@NonNull CancelSupport cancelSupport);
74	}

Lines 50-56 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/editor/overridden/ComputeAnnotations.java (-82 / +84 lines)
50	import java.util.Map;	50	import java.util.Map;
51	import java.util.Map.Entry;	51	import java.util.Map.Entry;
52	import java.util.Set;	52	import java.util.Set;
53	import java.util.concurrent.atomic.AtomicBoolean;
54	import java.util.logging.Level;	53	import java.util.logging.Level;
55	import java.util.logging.Logger;	54	import java.util.logging.Logger;
56	import javax.swing.text.BadLocationException;	55	import javax.swing.text.BadLocationException;
Lines 68-73 Link Here
68	import org.netbeans.modules.csl.core.GsfHtmlFormatter;	67	import org.netbeans.modules.csl.core.GsfHtmlFormatter;
69	import org.netbeans.modules.csl.core.Language;	68	import org.netbeans.modules.csl.core.Language;
70	import org.netbeans.modules.csl.core.LanguageRegistry;	69	import org.netbeans.modules.csl.core.LanguageRegistry;
		70	import org.netbeans.modules.csl.core.SpiSupportAccessor;
71	import org.netbeans.modules.csl.navigation.ElementScanningTask;	71	import org.netbeans.modules.csl.navigation.ElementScanningTask;
72	import org.netbeans.modules.csl.spi.ParserResult;	72	import org.netbeans.modules.csl.spi.ParserResult;
73	import org.netbeans.modules.parsing.api.Embedding;	73	import org.netbeans.modules.parsing.api.Embedding;
Lines 82-88 Link Here
82	import org.netbeans.modules.parsing.spi.Scheduler;	82	import org.netbeans.modules.parsing.spi.Scheduler;
83	import org.netbeans.modules.parsing.spi.SchedulerEvent;	83	import org.netbeans.modules.parsing.spi.SchedulerEvent;
84	import org.netbeans.modules.parsing.spi.SchedulerTask;	84	import org.netbeans.modules.parsing.spi.SchedulerTask;
85	import org.netbeans.modules.parsing.spi.TaskFactory;	85	import org.netbeans.modules.parsing.spi.support.CancelSupport;
86	import org.openide.filesystems.FileObject;	86	import org.openide.filesystems.FileObject;
87	import org.openide.text.NbDocument;	87	import org.openide.text.NbDocument;
88	import org.openide.util.NbBundle;	88	import org.openide.util.NbBundle;
Lines 91-200 Link Here
91	*	91	*
92	* @author lahvac	92	* @author lahvac
93	*/	93	*/
94	public class ComputeAnnotations extends ParserResultTask<Result> {	94	public final class ComputeAnnotations extends ParserResultTask<Result> {
95		95
96	private static final Logger LOG = Logger.getLogger(ComputeAnnotations.class.getName());	96	private static final Logger LOG = Logger.getLogger(ComputeAnnotations.class.getName());
97	private final AtomicBoolean cancel = new AtomicBoolean();	97	private final CancelSupport cancel = CancelSupport.create(this);
98		98
99	@Override	99	@Override
100	public void run(Result result, SchedulerEvent event) {	100	public void run(Result result, SchedulerEvent event) {
101	if (!(result instanceof ParserResult)) {	101	if (!(result instanceof ParserResult)) {
102	return;	102	return;
103	}	103	}
		104	SpiSupportAccessor.getInstance().setCancelSupport(cancel);
		105	try {
		106	final FileObject file = result.getSnapshot().getSource().getFileObject();
104		107
105	cancel.set(false);	108	if (file == null) {
106		109	return;
107	final FileObject file = result.getSnapshot().getSource().getFileObject();	110	}
108		111
109	if (file == null) {	112	final StyledDocument doc = (StyledDocument) result.getSnapshot().getSource().getDocument(false);
110	return;
111	}
112		113
113	final StyledDocument doc = (StyledDocument) result.getSnapshot().getSource().getDocument(false);	114	if (doc == null) {
		115	return;
		116	}
114		117
115	if (doc == null) {	118	final List<IsOverriddenAnnotation> annotations = new LinkedList<IsOverriddenAnnotation>();
116	return;	119	try {
117	}	120	ParserManager.parse(Collections.singleton(result.getSnapshot().getSource()), new UserTask() {
		121	public @Override void run(ResultIterator resultIterator) throws Exception {
		122	Language language = LanguageRegistry.getInstance().getLanguageByMimeType(resultIterator.getSnapshot().getMimeType());
		123	if(language != null) { //check for non csl results
		124	StructureScanner scanner = language.getStructure();
		125	OverridingMethods om = language.getOverridingMethods();
		126	if (scanner != null && om != null) {
		127	Parser.Result r = resultIterator.getParserResult();
		128	if (r instanceof ParserResult) {
		129	Map<ElementHandle, Collection<? extends AlternativeLocation>> overriding = new HashMap<ElementHandle, Collection<? extends AlternativeLocation>>();
		130	Map<ElementHandle, Collection<? extends AlternativeLocation>> overridden = new HashMap<ElementHandle, Collection<? extends AlternativeLocation>>();
		131	Set<ElementHandle> seen = new HashSet<ElementHandle>();
		132	Map<ElementHandle, ElementHandle> node2Parent = new HashMap<ElementHandle, ElementHandle>();
118		133
119	final List<IsOverriddenAnnotation> annotations = new LinkedList<IsOverriddenAnnotation>();	134	List<? extends StructureItem> children = ElementScanningTask.findCachedStructure(resultIterator.getSnapshot(), r);
120	try {	135	if (children == null) {
121	ParserManager.parse(Collections.singleton(result.getSnapshot().getSource()), new UserTask() {	136	long startTime = System.currentTimeMillis();
122	public @Override void run(ResultIterator resultIterator) throws Exception {	137	children = scanner.scan((ParserResult) r);
123	Language language = LanguageRegistry.getInstance().getLanguageByMimeType(resultIterator.getSnapshot().getMimeType());
124	if(language != null) { //check for non csl results
125	StructureScanner scanner = language.getStructure();
126	OverridingMethods om = language.getOverridingMethods();
127	if (scanner != null && om != null) {
128	Parser.Result r = resultIterator.getParserResult();
129	if (r instanceof ParserResult) {
130	Map<ElementHandle, Collection<? extends AlternativeLocation>> overriding = new HashMap<ElementHandle, Collection<? extends AlternativeLocation>>();
131	Map<ElementHandle, Collection<? extends AlternativeLocation>> overridden = new HashMap<ElementHandle, Collection<? extends AlternativeLocation>>();
132	Set<ElementHandle> seen = new HashSet<ElementHandle>();
133	Map<ElementHandle, ElementHandle> node2Parent = new HashMap<ElementHandle, ElementHandle>();
134
135	List<? extends StructureItem> children = ElementScanningTask.findCachedStructure(resultIterator.getSnapshot(), r);
136	if (children == null) {
137	long startTime = System.currentTimeMillis();
138	children = scanner.scan((ParserResult) r);
139		138
140	long endTime = System.currentTimeMillis();	139	long endTime = System.currentTimeMillis();
141	Logger.getLogger("TIMER").log(Level.FINE, "Structure (" + language.getMimeType() + ")",	140	Logger.getLogger("TIMER").log(Level.FINE, "Structure (" + language.getMimeType() + ")",
142	new Object[]{file, endTime - startTime});	141	new Object[]{file, endTime - startTime});
143	ElementScanningTask.markProcessed(r, children);	142	ElementScanningTask.markProcessed(r, children);
144	}	143	}
145	List<StructureItem> todo = new LinkedList<StructureItem>(children);	144	List<StructureItem> todo = new LinkedList<StructureItem>(children);
146
147	while (!todo.isEmpty()) {
148	StructureItem i = todo.remove(0);
149		145
150	todo.addAll(i.getNestedItems());	146	while (!todo.isEmpty()) {
		147	StructureItem i = todo.remove(0);
151		148
152	for (StructureItem nested : i.getNestedItems()) {	149	todo.addAll(i.getNestedItems());
153	if (!node2Parent.containsKey(nested.getElementHandle())) {	150
154	node2Parent.put(nested.getElementHandle(), i.getElementHandle());	151	for (StructureItem nested : i.getNestedItems()) {
		152	if (!node2Parent.containsKey(nested.getElementHandle())) {
		153	node2Parent.put(nested.getElementHandle(), i.getElementHandle());
		154	}
		155	}
		156
		157	if (seen.add(i.getElementHandle())) {
		158	if (i.getElementHandle().getKind() != ElementKind.CLASS && i.getElementHandle().getKind() != ElementKind.INTERFACE) {
		159	Collection<? extends AlternativeLocation> ov = om.overrides((ParserResult) r, i.getElementHandle());
		160
		161	if (ov != null && !ov.isEmpty()) {
		162	overriding.put(i.getElementHandle(), ov);
		163	}
		164	}
		165
		166	if (om.isOverriddenBySupported((ParserResult) r, i.getElementHandle())) {
		167	Collection<? extends AlternativeLocation> on = om.overriddenBy((ParserResult) r, i.getElementHandle());
		168
		169	if (on != null && !on.isEmpty()) {
		170	overridden.put(i.getElementHandle(), on);
		171	}
		172	}
155	}	173	}
156	}	174	}
157		175
158	if (seen.add(i.getElementHandle())) {	176	createAnnotations((ParserResult) r, doc, overriding, node2Parent, false, annotations);
159	if (i.getElementHandle().getKind() != ElementKind.CLASS && i.getElementHandle().getKind() != ElementKind.INTERFACE) {	177	createAnnotations((ParserResult) r, doc, overridden, node2Parent, true, annotations);
160	Collection<? extends AlternativeLocation> ov = om.overrides((ParserResult) r, i.getElementHandle());
161
162	if (ov != null && !ov.isEmpty()) {
163	overriding.put(i.getElementHandle(), ov);
164	}
165	}
166
167	if (om.isOverriddenBySupported((ParserResult) r, i.getElementHandle())) {
168	Collection<? extends AlternativeLocation> on = om.overriddenBy((ParserResult) r, i.getElementHandle());
169
170	if (on != null && !on.isEmpty()) {
171	overridden.put(i.getElementHandle(), on);
172	}
173	}
174	}
175	}	178	}
176
177	createAnnotations((ParserResult) r, doc, overriding, node2Parent, false, annotations);
178	createAnnotations((ParserResult) r, doc, overridden, node2Parent, true, annotations);
179	}	179	}
180	}	180	}
		181
		182	for(Embedding e : resultIterator.getEmbeddings()) {
		183	run(resultIterator.getResultIterator(e));
		184	}
181	}	185	}
		186	});
		187	} catch (ParseException e) {
		188	LOG.log(Level.WARNING, null, e);
		189	}
182		190
183	for(Embedding e : resultIterator.getEmbeddings()) {	191	AnnotationsHolder holder = AnnotationsHolder.get(file);
184	run(resultIterator.getResultIterator(e));	192
185	}	193	if (holder != null) {
186	}	194	holder.setNewAnnotations(annotations);
187	});	195	}
188	} catch (ParseException e) {	196	// Logger.getLogger("TIMER").log(Level.FINE, "Is Overridden Annotations", new Object[] {info.getFileObject(), end - start});
189	LOG.log(Level.WARNING, null, e);	197	} finally {
		198	SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
190	}	199	}
191		200
192	AnnotationsHolder holder = AnnotationsHolder.get(file);
193
194	if (holder != null) {
195	holder.setNewAnnotations(annotations);
196	}
197	// Logger.getLogger("TIMER").log(Level.FINE, "Is Overridden Annotations", new Object[] {info.getFileObject(), end - start});
198	}	201	}
199		202
200	private void createAnnotations(ParserResult r, StyledDocument doc, Map<ElementHandle, Collection<? extends AlternativeLocation>> descriptions, Map<ElementHandle, ElementHandle> node2Parent, boolean overridden, List<IsOverriddenAnnotation> annotations) {	203	private void createAnnotations(ParserResult r, StyledDocument doc, Map<ElementHandle, Collection<? extends AlternativeLocation>> descriptions, Map<ElementHandle, ElementHandle> node2Parent, boolean overridden, List<IsOverriddenAnnotation> annotations) {
Lines 279-287 Link Here
279		282
280	@Override	283	@Override
281	public void cancel() {	284	public void cancel() {
282	cancel.set(true);
283	}	285	}
284		286
285	private static Position getPosition(final StyledDocument doc, final int offset) {	287	private static Position getPosition(final StyledDocument doc, final int offset) {
286	class Impl implements Runnable {	288	class Impl implements Runnable {
287	private Position pos;	289	private Position pos;

Lines 45-51 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/editor/semantic/MarkOccurrencesHighlighter.java (-62 / +57 lines)
45		45
46	import java.awt.Color;	46	import java.awt.Color;
47	import java.util.ArrayList;	47	import java.util.ArrayList;
48	import java.util.Collections;
49	import java.util.List;	48	import java.util.List;
50	import java.util.Map;	49	import java.util.Map;
51	import java.util.SortedSet;	50	import java.util.SortedSet;
Lines 60-70 Link Here
60	import org.netbeans.modules.csl.spi.ParserResult;	59	import org.netbeans.modules.csl.spi.ParserResult;
61	import org.netbeans.modules.csl.core.Language;	60	import org.netbeans.modules.csl.core.Language;
62	import org.netbeans.modules.csl.api.ColoringAttributes.Coloring;	61	import org.netbeans.modules.csl.api.ColoringAttributes.Coloring;
		62	import org.netbeans.modules.csl.core.SpiSupportAccessor;
63	import org.netbeans.modules.parsing.api.Snapshot;	63	import org.netbeans.modules.parsing.api.Snapshot;
64	import org.netbeans.modules.parsing.spi.CursorMovedSchedulerEvent;	64	import org.netbeans.modules.parsing.spi.CursorMovedSchedulerEvent;
65	import org.netbeans.modules.parsing.spi.ParserResultTask;	65	import org.netbeans.modules.parsing.spi.ParserResultTask;
66	import org.netbeans.modules.parsing.spi.Scheduler;	66	import org.netbeans.modules.parsing.spi.Scheduler;
67	import org.netbeans.modules.parsing.spi.SchedulerEvent;	67	import org.netbeans.modules.parsing.spi.SchedulerEvent;
		68	import org.netbeans.modules.parsing.spi.support.CancelSupport;
68	import org.netbeans.spi.editor.highlighting.support.AbstractHighlightsContainer;	69	import org.netbeans.spi.editor.highlighting.support.AbstractHighlightsContainer;
69	import org.openide.ErrorManager;	70	import org.openide.ErrorManager;
70	import org.openide.util.NbBundle;	71	import org.openide.util.NbBundle;
Lines 78-88 Link Here
78	*	79	*
79	* @author Jan Lahoda	80	* @author Jan Lahoda
80	*/	81	*/
81	public class MarkOccurrencesHighlighter extends ParserResultTask<ParserResult> {	82	public final class MarkOccurrencesHighlighter extends ParserResultTask<ParserResult> {
82		83
83	private static final Logger LOG = Logger.getLogger(MarkOccurrencesHighlighter.class.getName());	84	private static final Logger LOG = Logger.getLogger(MarkOccurrencesHighlighter.class.getName());
84		85
85	//private FileObject file;	86	//private FileObject file;
		87	private final CancelSupport cancel = CancelSupport.create(this);
86	private final Language language;	88	private final Language language;
87	private final Snapshot snapshot;	89	private final Snapshot snapshot;
88	private int version;	90	private int version;
Lines 101-159 Link Here
101	// }	103	// }
102	//	104	//
103	public void run(ParserResult info, SchedulerEvent event) {	105	public void run(ParserResult info, SchedulerEvent event) {
104	resume();	106	SpiSupportAccessor.getInstance().setCancelSupport(cancel);
105		107	try {
106	Document doc = snapshot.getSource().getDocument(false);	108	Document doc = snapshot.getSource().getDocument(false);
107
108	if (doc == null) {
109	LOG.log(Level.INFO, "MarkOccurencesHighlighter: Cannot get document!"); //NOI18N
110	return ;
111	}
112
113	if (!(event instanceof CursorMovedSchedulerEvent)) {
114	return;
115	}
116		109
117	int caretPosition = ((CursorMovedSchedulerEvent) event).getCaretOffset();	110	if (doc == null) {
118		111	LOG.log(Level.INFO, "MarkOccurencesHighlighter: Cannot get document!"); //NOI18N
119	if (isCancelled()) {	112	return ;
120	return;	113	}
121	}
122
123	int snapshotOffset = info.getSnapshot().getEmbeddedOffset(caretPosition);
124		114
125	if (snapshotOffset == -1) {	115	if (!(event instanceof CursorMovedSchedulerEvent)) {
126	// caret offset not part of this lang embedding, ignore, since	116	return;
127	// we cannot assume identifiers in different languages match.	117	}
128	return;
129	}
130		118
131	List<OffsetRange> bag = processImpl(info, doc, caretPosition);	119	int caretPosition = ((CursorMovedSchedulerEvent) event).getCaretOffset();
132	if(bag == null) {
133	//the occurrences finder haven't found anything, just ignore the result
134	//and keep the previous occurrences
135	return ;
136	}
137		120
138	if (isCancelled()) {	121	if (cancel.isCancelled()) {
139	return;	122	return;
140	}	123	}
141
142	GsfSemanticLayer layer = GsfSemanticLayer.getLayer(MarkOccurrencesHighlighter.class, doc);
143	SortedSet seqs = new TreeSet<SequenceElement>();
144		124
145	if (bag.size() > 0) {	125	int snapshotOffset = info.getSnapshot().getEmbeddedOffset(caretPosition);
146	for (OffsetRange range : bag) {	126
147	if (range != OffsetRange.NONE) {	127	if (snapshotOffset == -1) {
148	SequenceElement s = new SequenceElement(language, range, MO);	128	// caret offset not part of this lang embedding, ignore, since
149	seqs.add(s);	129	// we cannot assume identifiers in different languages match.
		130	return;
		131	}
		132
		133	List<OffsetRange> bag = processImpl(info, doc, caretPosition);
		134	if(bag == null) {
		135	//the occurrences finder haven't found anything, just ignore the result
		136	//and keep the previous occurrences
		137	return ;
		138	}
		139
		140	if (cancel.isCancelled()) {
		141	return;
		142	}
		143
		144	GsfSemanticLayer layer = GsfSemanticLayer.getLayer(MarkOccurrencesHighlighter.class, doc);
		145	SortedSet seqs = new TreeSet<SequenceElement>();
		146
		147	if (bag.size() > 0) {
		148	for (OffsetRange range : bag) {
		149	if (range != OffsetRange.NONE) {
		150	SequenceElement s = new SequenceElement(language, range, MO);
		151	seqs.add(s);
		152	}
150	}	153	}
151	}	154	}
		155
		156	layer.setColorings(seqs, version++);
		157
		158	OccurrencesMarkProvider.get(doc).setOccurrences(OccurrencesMarkProvider.createMarks(doc, bag, ES_COLOR, NbBundle.getMessage(MarkOccurrencesHighlighter.class, "LBL_ES_TOOLTIP")));
		159	} finally {
		160	SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
152	}	161	}
153
154	layer.setColorings(seqs, version++);
155
156	OccurrencesMarkProvider.get(doc).setOccurrences(OccurrencesMarkProvider.createMarks(doc, bag, ES_COLOR, NbBundle.getMessage(MarkOccurrencesHighlighter.class, "LBL_ES_TOOLTIP")));
157	}	162	}
158		163
159	@NonNull	164	@NonNull
Lines 168-174 Link Here
168	ErrorManager.getDefault().notify(ex);	173	ErrorManager.getDefault().notify(ex);
169	}	174	}
170		175
171	if (isCancelled()) {	176	if (cancel.isCancelled()) {
172	finder.cancel();	177	finder.cancel();
173	}	178	}
174		179
Lines 186-206 Link Here
186	public Class<? extends Scheduler> getSchedulerClass () {	191	public Class<? extends Scheduler> getSchedulerClass () {
187	return Scheduler.CURSOR_SENSITIVE_TASK_SCHEDULER;	192	return Scheduler.CURSOR_SENSITIVE_TASK_SCHEDULER;
188	}	193	}
189		194
190	private boolean canceled;	195	@Override
191		196	public final void cancel() {
192	public final synchronized void cancel() {
193	canceled = true;
194	}	197	}
195		198
196	protected final synchronized boolean isCancelled() {
197	return canceled;
198	}
199
200	protected final synchronized void resume() {
201	canceled = false;
202	}
203
204	public static AbstractHighlightsContainer getHighlightsBag(Document doc) {	199	public static AbstractHighlightsContainer getHighlightsBag(Document doc) {
205	GsfSemanticLayer highlight = GsfSemanticLayer.getLayer(MarkOccurrencesHighlighter.class, doc);	200	GsfSemanticLayer highlight = GsfSemanticLayer.getLayer(MarkOccurrencesHighlighter.class, doc);
206	return highlight;	201	return highlight;

Lines 69-74 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/hints/GsfHintsProvider.java (-29 / +18 lines)
69	import org.netbeans.modules.csl.api.Hint;	69	import org.netbeans.modules.csl.api.Hint;
70	import org.netbeans.modules.csl.api.OffsetRange;	70	import org.netbeans.modules.csl.api.OffsetRange;
71	import org.netbeans.modules.csl.api.RuleContext;	71	import org.netbeans.modules.csl.api.RuleContext;
		72	import org.netbeans.modules.csl.core.SpiSupportAccessor;
72	import org.netbeans.modules.csl.hints.infrastructure.GsfHintsManager;	73	import org.netbeans.modules.csl.hints.infrastructure.GsfHintsManager;
73	import org.netbeans.modules.csl.spi.ParserResult;	74	import org.netbeans.modules.csl.spi.ParserResult;
74	import org.netbeans.modules.parsing.api.Embedding;	75	import org.netbeans.modules.parsing.api.Embedding;
Lines 79-84 Link Here
79	import org.netbeans.modules.parsing.spi.ParseException;	80	import org.netbeans.modules.parsing.spi.ParseException;
80	import org.netbeans.modules.parsing.spi.ParserResultTask;	81	import org.netbeans.modules.parsing.spi.ParserResultTask;
81	import org.netbeans.modules.parsing.spi.SchedulerEvent;	82	import org.netbeans.modules.parsing.spi.SchedulerEvent;
		83	import org.netbeans.modules.parsing.spi.support.CancelSupport;
82	import org.netbeans.spi.editor.hints.ErrorDescription;	84	import org.netbeans.spi.editor.hints.ErrorDescription;
83	import org.netbeans.spi.editor.hints.ErrorDescriptionFactory;	85	import org.netbeans.spi.editor.hints.ErrorDescriptionFactory;
84	import org.netbeans.spi.editor.hints.HintsController;	86	import org.netbeans.spi.editor.hints.HintsController;
Lines 101-107 Link Here
101	public final class GsfHintsProvider extends ParserResultTask<ParserResult> {	103	public final class GsfHintsProvider extends ParserResultTask<ParserResult> {
102		104
103	public static final Logger LOG = Logger.getLogger(GsfHintsProvider.class.getName()); // NOI18N	105	public static final Logger LOG = Logger.getLogger(GsfHintsProvider.class.getName()); // NOI18N
104		106
		107	private final CancelSupport cancel = CancelSupport.create(this);
105	private FileObject file;	108	private FileObject file;
106		109
107	/**	110	/**
Lines 133-139 Link Here
133	}	136	}
134		137
135	for (Error d : errors) {	138	for (Error d : errors) {
136	if (isCanceled()) {	139	if (cancel.isCancelled()) {
137	return null;	140	return null;
138	}	141	}
139		142
Lines 178-184 Link Here
178	final String desc = d.getDisplayName();	181	final String desc = d.getDisplayName();
179	final Position[] range = getLine(d, doc, position, endPosition);	182	final Position[] range = getLine(d, doc, position, endPosition);
180		183
181	if (isCanceled()) {	184	if (cancel.isCancelled()) {
182	return null;	185	return null;
183	}	186	}
184		187
Lines 189-195 Link Here
189	descs.add(ErrorDescriptionFactory.createErrorDescription(errorKind2Severity.get(d.getSeverity()), desc, ehm, doc, range[0], range[1]));	192	descs.add(ErrorDescriptionFactory.createErrorDescription(errorKind2Severity.get(d.getSeverity()), desc, ehm, doc, range[0], range[1]));
190	}	193	}
191		194
192	if (isCanceled()) {	195	if (cancel.isCancelled()) {
193	return null;	196	return null;
194	}	197	}
195		198
Lines 209-215 Link Here
209	// under the document read-lock.	212	// under the document read-lock.
210	doc.render(new Runnable() {	213	doc.render(new Runnable() {
211	public void run() {	214	public void run() {
212	if (isCanceled()) {	215	if (cancel.isCancelled()) {
213	return;	216	return;
214	}	217	}
215	ret[0] = getLine0(d, doc, startOffset, endOffset);	218	ret[0] = getLine0(d, doc, startOffset, endOffset);
Lines 259-265 Link Here
259	int len = doc.getLength();	262	int len = doc.getLength();
260		263
261	if (startOffsetFinal > len \|\| endOffsetFinal > len) {	264	if (startOffsetFinal > len \|\| endOffsetFinal > len) {
262	if (!isCanceled() && LOG.isLoggable(Level.WARNING)) {	265	if (!cancel.isCancelled() && LOG.isLoggable(Level.WARNING)) {
263	LOG.log(Level.WARNING, "document changed, but not canceled?" );	266	LOG.log(Level.WARNING, "document changed, but not canceled?" );
264	LOG.log(Level.WARNING, "len = " + len );	267	LOG.log(Level.WARNING, "len = " + len );
265	LOG.log(Level.WARNING, "startOffset = " + startOffsetFinal );	268	LOG.log(Level.WARNING, "startOffset = " + startOffsetFinal );
Lines 279-307 Link Here
279		282
280	return result;	283	return result;
281	}	284	}
282		285
283	private boolean cancel;	286
284
285	synchronized boolean isCanceled() {
286	return cancel;
287	}
288
289	@Override	287	@Override
290	public void cancel() {	288	public void cancel() {
291	HintsProvider curProvider;	289	final HintsProvider curProvider = this.pendingProvider;
292	synchronized (this) {
293	curProvider = this.pendingProvider;
294	cancel = true;
295	}
296	if (curProvider != null) {	290	if (curProvider != null) {
297	curProvider.cancel();	291	curProvider.cancel();
298	}	292	}
299	}	293	}
300		294
301	synchronized void resume() {
302	cancel = false;
303	}
304
305	private List<Error> processProviderErrors(	295	private List<Error> processProviderErrors(
306	final List<ErrorDescription> descriptions,	296	final List<ErrorDescription> descriptions,
307	Snapshot topLevelSnapshot, final ParserResult r, final Language language) throws ParseException {	297	Snapshot topLevelSnapshot, final ParserResult r, final Language language) throws ParseException {
Lines 324-330 Link Here
324	try {	314	try {
325	synchronized (this) {	315	synchronized (this) {
326	pendingProvider = provider;	316	pendingProvider = provider;
327	if (isCanceled()) {	317	if (cancel.isCancelled()) {
328	return errors;	318	return errors;
329	}	319	}
330	}	320	}
Lines 377-383 Link Here
377		367
378	for(Embedding e : resultIterator.getEmbeddings()) {	368	for(Embedding e : resultIterator.getEmbeddings()) {
379	try {	369	try {
380	if (isCanceled()) {	370	if (cancel.isCancelled()) {
381	return;	371	return;
382	}	372	}
383	} catch (Exception ex) {	373	} catch (Exception ex) {
Lines 429-443 Link Here
429	}	419	}
430		420
431	public @Override void run(ParserResult result, SchedulerEvent event) {	421	public @Override void run(ParserResult result, SchedulerEvent event) {
432	resume();
433
434	final Document doc = getDocument();	422	final Document doc = getDocument();
435
436	if (doc == null) {	423	if (doc == null) {
437	LOG.log(Level.INFO, "SemanticHighlighter: Cannot get document!");	424	LOG.log(Level.INFO, "SemanticHighlighter: Cannot get document!");
438	return ;	425	return ;
439	}	426	}
440		427	SpiSupportAccessor.getInstance().setCancelSupport(cancel);
441	try {	428	try {
442	ParserManager.parse(Collections.singleton(result.getSnapshot().getSource()), new UserTask() {	429	ParserManager.parse(Collections.singleton(result.getSnapshot().getSource()), new UserTask() {
443	public @Override void run(ResultIterator resultIterator) throws ParseException {	430	public @Override void run(ResultIterator resultIterator) throws ParseException {
Lines 447-452 Link Here
447	});	434	});
448	} catch (ParseException e) {	435	} catch (ParseException e) {
449	LOG.log(Level.WARNING, null, e);	436	LOG.log(Level.WARNING, null, e);
		437	} finally {
		438	SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
450	}	439	}
451	}	440	}
452		441

Lines 80-85 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/navigation/BreadCrumbsTask.java (-30 / +39 lines)
80	*/	80	*/
81	public class BreadCrumbsTask extends ElementScanningTask {	81	public class BreadCrumbsTask extends ElementScanningTask {
82		82
		83	public BreadCrumbsTask() {
		84	}
		85
83	private static final RequestProcessor WORKER = new RequestProcessor(BreadCrumbsTask.class.getName(), 1, false, false);	86	private static final RequestProcessor WORKER = new RequestProcessor(BreadCrumbsTask.class.getName(), 1, false, false);
84		87
85	@Override	88	@Override
Lines 95-130 Link Here
95	private final AtomicLong requestId = new AtomicLong();	98	private final AtomicLong requestId = new AtomicLong();
96		99
97	@Override	100	@Override
98	public void run(ParserResult result, SchedulerEvent event) {	101	public void run(final ParserResult result, final SchedulerEvent event) {
99	final long id = requestId.incrementAndGet();	102	runWithCancelService(new Runnable() {
100		103	@Override
101	final Document doc = result.getSnapshot().getSource().getDocument(false);	104	public void run() {
102		105	resume();
103	if (doc == null \|\| !BreadcrumbsController.areBreadCrumsEnabled(doc)) return ;	106	final long id = requestId.incrementAndGet();
104		107
105	final int caret;	108	final Document doc = result.getSnapshot().getSource().getDocument(false);
106		109
107	if (event instanceof CursorMovedSchedulerEvent) {	110	if (doc == null \|\| !BreadcrumbsController.areBreadCrumsEnabled(doc)) return ;
108	caret = ((CursorMovedSchedulerEvent) event).getCaretOffset();	111
109	} else {	112	final int caret;
110	//XXX: outside AWT!	113
111	JTextComponent c = EditorRegistry.focusedComponent();	114	if (event instanceof CursorMovedSchedulerEvent) {
112		115	caret = ((CursorMovedSchedulerEvent) event).getCaretOffset();
113	if (c != null && c.getDocument() == doc)	116	} else {
114	caret = c.getCaretPosition();	117	//XXX: outside AWT!
115	else	118	JTextComponent c = EditorRegistry.focusedComponent();
116	caret = (-1);	119
117	}	120	if (c != null && c.getDocument() == doc)
118		121	caret = c.getCaretPosition();
119	if (caret == (-1)) return ;	122	else
120		123	caret = (-1);
121	final StructureItem structureRoot = computeStructureRoot(result.getSnapshot().getSource());	124	}
122		125
123	if (structureRoot == null) return ;	126	if (caret == (-1)) return ;
124		127
125	WORKER.post(new Runnable() {	128	final StructureItem structureRoot = computeStructureRoot(result.getSnapshot().getSource());
126	@Override public void run() {	129
127	selectNode(doc, structureRoot, id, caret);	130	if (structureRoot == null) return ;
		131
		132	WORKER.post(new Runnable() {
		133	@Override public void run() {
		134	selectNode(doc, structureRoot, id, caret);
		135	}
		136	});
128	}	137	}
129	});	138	});
130	}	139	}

Lines 44-51 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/navigation/CaretListeningTask.java (-23 / +17 lines)
44		44
45	package org.netbeans.modules.csl.navigation;	45	package org.netbeans.modules.csl.navigation;
46		46
		47	import org.netbeans.modules.csl.core.SpiSupportAccessor;
47	import org.netbeans.modules.csl.spi.ParserResult;	48	import org.netbeans.modules.csl.spi.ParserResult;
48	import org.netbeans.modules.parsing.spi.*;	49	import org.netbeans.modules.parsing.spi.*;
		50	import org.netbeans.modules.parsing.spi.support.CancelSupport;
49		51
50	/**	52	/**
51	* This file is originally from Retouche, the Java Support	53	* This file is originally from Retouche, the Java Support
Lines 56-98 Link Here
56	* This task is called every time the caret position changes in a GSF editor.	58	* This task is called every time the caret position changes in a GSF editor.
57	* It delegates to the navigator to show the current selection.	59	* It delegates to the navigator to show the current selection.
58	*/	60	*/
59	public class CaretListeningTask extends IndexingAwareParserResultTask<ParserResult> {	61	public final class CaretListeningTask extends IndexingAwareParserResultTask<ParserResult> {
60		62
61	private boolean canceled;	63	private final CancelSupport cancel = CancelSupport.create(this);
62		64
63	CaretListeningTask() {	65	CaretListeningTask() {
64	super(TaskIndexingMode.ALLOWED_DURING_SCAN);	66	super(TaskIndexingMode.ALLOWED_DURING_SCAN);
65	}	67	}
66		68
67	public @Override void run(ParserResult result, SchedulerEvent event) {	69	public @Override void run(ParserResult result, SchedulerEvent event) {
68	resume();	70
69
70	boolean navigatorShouldUpdate = ClassMemberPanel.getInstance() != null; // XXX set by navigator visible	71	boolean navigatorShouldUpdate = ClassMemberPanel.getInstance() != null; // XXX set by navigator visible
71		72	if (cancel.isCancelled() \|\| (!navigatorShouldUpdate) \|\| !(event instanceof CursorMovedSchedulerEvent)) {
72	if (isCancelled() \|\| (!navigatorShouldUpdate) \|\| !(event instanceof CursorMovedSchedulerEvent)) {
73	return;	73	return;
74	}	74	}
75		75
76	int offset = ((CursorMovedSchedulerEvent) event).getCaretOffset();	76	SpiSupportAccessor.getInstance().setCancelSupport(cancel);
77	if (offset != -1) {	77	try {
78	ClassMemberPanel.getInstance().selectElement(result, offset);	78	int offset = ((CursorMovedSchedulerEvent) event).getCaretOffset();
		79	if (offset != -1) {
		80	ClassMemberPanel.getInstance().selectElement(result, offset);
		81	}
		82	} finally {
		83	SpiSupportAccessor.getInstance().removeCancelSupport(cancel);
79	}	84	}
80	}	85	}
81		86
82	/**	87
83	* After this method is called the task if running should exit the run	88	@Override
84	* method immediately.
85	*/
86	public final synchronized void cancel() {	89	public final synchronized void cancel() {
87	canceled = true;
88	}
89
90	protected final synchronized boolean isCancelled() {
91	return canceled;
92	}
93
94	protected final synchronized void resume() {
95	canceled = false;
96	}	90	}
97		91
98	public @Override int getPriority() {	92	public @Override int getPriority() {