Attachment #162393 for bug #268402

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 268402
Collapse All | Expand All

Lines 50-54 Link Here

(-)a/cnd.refactoring/src/org/netbeans/modules/cnd/refactoring/api/WhereUsedQueryConstants.java (-1 / +2 lines)
50	FIND_OVERRIDING_METHODS,	50	FIND_OVERRIDING_METHODS,
51	FIND_SUBCLASSES,	51	FIND_SUBCLASSES,
52	FIND_DIRECT_SUBCLASSES,	52	FIND_DIRECT_SUBCLASSES,
53	SEARCH_FROM_BASECLASS;	53	SEARCH_FROM_BASECLASS,
		54	READ_WRITE;
54	}	55	}

Lines 30-42 Link Here

(-)a/cnd.refactoring/src/org/netbeans/modules/cnd/refactoring/elements/CsmRefactoringElementImpl.java (-4 / +34 lines)
30	*/	30	*/
31	package org.netbeans.modules.cnd.refactoring.elements;	31	package org.netbeans.modules.cnd.refactoring.elements;
32		32
		33	import java.util.Collection;
33	import java.util.EnumSet;	34	import java.util.EnumSet;
		35	import java.util.concurrent.atomic.AtomicReference;
34	import javax.swing.Icon;	36	import javax.swing.Icon;
35	import javax.swing.text.BadLocationException;	37	import javax.swing.text.BadLocationException;
36	import javax.swing.text.StyledDocument;	38	import javax.swing.text.StyledDocument;
37	import org.netbeans.api.editor.document.LineDocumentUtils;	39	import org.netbeans.api.editor.document.LineDocumentUtils;
		40	import org.netbeans.api.lexer.Token;
		41	import org.netbeans.api.lexer.TokenId;
		42	import org.netbeans.api.lexer.TokenSequence;
		43	import org.netbeans.cnd.api.lexer.CndLexerUtilities;
		44	import org.netbeans.cnd.api.lexer.CppTokenId;
38	import org.netbeans.editor.BaseDocument;	45	import org.netbeans.editor.BaseDocument;
39	import org.netbeans.modules.cnd.api.model.CsmFile;	46	import org.netbeans.modules.cnd.api.model.CsmFile;
		47	import org.netbeans.modules.cnd.api.model.CsmObject;
		48	import org.netbeans.modules.cnd.api.model.util.CsmKindUtilities;
40	import org.netbeans.modules.cnd.api.model.xref.CsmReference;	49	import org.netbeans.modules.cnd.api.model.xref.CsmReference;
41	import org.netbeans.modules.cnd.api.model.xref.CsmReferenceKind;	50	import org.netbeans.modules.cnd.api.model.xref.CsmReferenceKind;
42	import org.netbeans.modules.cnd.api.model.xref.CsmReferenceResolver;	51	import org.netbeans.modules.cnd.api.model.xref.CsmReferenceResolver;
Lines 60-65 Link Here
60	*/	69	*/
61	public class CsmRefactoringElementImpl extends SimpleRefactoringElementImplementation	70	public class CsmRefactoringElementImpl extends SimpleRefactoringElementImplementation
62	implements FiltersManager.Filterable {	71	implements FiltersManager.Filterable {
		72
		73	public enum RW {
		74	Read,
		75	Write,
		76	ReadWrite
		77	}
63	private static final boolean LAZY = false;	78	private static final boolean LAZY = false;
64	private final CsmReference elem;	79	private final CsmReference elem;
65	private final PositionBounds bounds;	80	private final PositionBounds bounds;
Lines 72-80 Link Here
72	private final boolean isInMacros;	87	private final boolean isInMacros;
73	private final boolean isInDeadCode;	88	private final boolean isInDeadCode;
74	private final boolean isInComments;	89	private final boolean isInComments;
		90	private final RW rw;
75		91
76	public CsmRefactoringElementImpl(PositionBounds bounds,	92	public CsmRefactoringElementImpl(PositionBounds bounds,
77	CsmReference elem, FileObject fo, String displayText) {	93	CsmReference elem, FileObject fo, String displayText, CsmObject referencedObject) {
78	this.elem = elem;	94	this.elem = elem;
79	this.bounds = bounds;	95	this.bounds = bounds;
80	this.fo = fo;	96	this.fo = fo;
Lines 90-95 Link Here
90	this.isInMacros = CsmReferenceResolver.getDefault().isKindOf(elem, EnumSet.of(CsmReferenceKind.IN_PREPROCESSOR_DIRECTIVE));	106	this.isInMacros = CsmReferenceResolver.getDefault().isKindOf(elem, EnumSet.of(CsmReferenceKind.IN_PREPROCESSOR_DIRECTIVE));
91	this.isInDeadCode = CsmReferenceResolver.getDefault().isKindOf(elem, EnumSet.of(CsmReferenceKind.IN_DEAD_BLOCK));	107	this.isInDeadCode = CsmReferenceResolver.getDefault().isKindOf(elem, EnumSet.of(CsmReferenceKind.IN_DEAD_BLOCK));
92	this.isInComments = CsmReferenceResolver.getDefault().isKindOf(elem, EnumSet.of(CsmReferenceKind.COMMENT));	108	this.isInComments = CsmReferenceResolver.getDefault().isKindOf(elem, EnumSet.of(CsmReferenceKind.COMMENT));
		109	if (referencedObject != null && CsmKindUtilities.isVariable(referencedObject)) {
		110	this.rw = new TokenProcessor(elem).process();
		111	} else {
		112	this.rw = RW.Read;
		113	}
93	}	114	}
94		115
95	private boolean isScope(CsmReference ref) {	116	private boolean isScope(CsmReference ref) {
Lines 111-117 Link Here
111	}	132	}
112	return false;	133	return false;
113	}	134	}
114		135
115	@Override	136	@Override
116	public String getText() {	137	public String getText() {
117	return elem.getText().toString();	138	return elem.getText().toString();
Lines 153-168 Link Here
153	return "{" + "bounds=" + bounds + ", displayText=" + displayText + ", enclosing=" + enclosing + ", fo=" + fo + '}'; // NOI18N	174	return "{" + "bounds=" + bounds + ", displayText=" + displayText + ", enclosing=" + enclosing + ", fo=" + fo + '}'; // NOI18N
154	}	175	}
155		176
156	public static RefactoringElementImplementation create(CsmReference ref,boolean nameInBold) {	177	public static RefactoringElementImplementation create(CsmReference ref, boolean nameInBold, CsmObject referencedObject) {
157	CsmFile csmFile = ref.getContainingFile();	178	CsmFile csmFile = ref.getContainingFile();
158	FileObject fo = CsmUtilities.getFileObject(csmFile);	179	FileObject fo = CsmUtilities.getFileObject(csmFile);
159	PositionBounds bounds = CsmUtilities.createPositionBounds(ref);	180	PositionBounds bounds = CsmUtilities.createPositionBounds(ref);
160	String displayText = LAZY ? null : CsmReferenceSupport.getContextLineHtml(ref, nameInBold).toString();	181	String displayText = LAZY ? null : CsmReferenceSupport.getContextLineHtml(ref, nameInBold).toString();
161	return new CsmRefactoringElementImpl(bounds, ref, fo, displayText);	182	return new CsmRefactoringElementImpl(bounds, ref, fo, displayText, referencedObject);
162	}	183	}
163		184
164	@Override	185	@Override
165	public boolean filter(FiltersManager manager) {	186	public boolean filter(FiltersManager manager) {
		187	if (rw == RW.Read && !manager.isSelected(CsmWhereUsedFilters.READ.getKey())) {
		188	return false;
		189	}
		190	if (rw == RW.Write && !manager.isSelected(CsmWhereUsedFilters.WRITE.getKey())) {
		191	return false;
		192	}
		193	if (rw == RW.ReadWrite && !manager.isSelected(CsmWhereUsedFilters.READ_WRITE.getKey())) {
		194	return false;
		195	}
166	if (isDecl && !manager.isSelected(CsmWhereUsedFilters.DECLARATIONS.getKey())) {	196	if (isDecl && !manager.isSelected(CsmWhereUsedFilters.DECLARATIONS.getKey())) {
167	return false;	197	return false;
168	}	198	}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2016 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):
 */
package org.netbeans.modules.cnd.refactoring.elements;

import javax.swing.text.StyledDocument;
import org.netbeans.api.lexer.Token;
import org.netbeans.api.lexer.TokenId;
import org.netbeans.api.lexer.TokenSequence;
import org.netbeans.cnd.api.lexer.CndLexerUtilities;
import org.netbeans.cnd.api.lexer.CppTokenId;
import org.netbeans.editor.BaseDocument;
import org.netbeans.modules.cnd.api.model.CsmFile;
import org.netbeans.modules.cnd.api.model.xref.CsmReference;
import org.netbeans.modules.cnd.modelutil.CsmUtilities;
import org.openide.text.CloneableEditorSupport;

/**
 *
 * @author Alexander Simon
 */
public class TokenProcessor {

    private final CsmReference ref;
    private CsmRefactoringElementImpl.RW rw = CsmRefactoringElementImpl.RW.Read;

    TokenProcessor(CsmReference ref) {
        this.ref = ref;
    }

    CsmRefactoringElementImpl.RW process() {
        CsmFile csmFile = ref.getContainingFile();
        CloneableEditorSupport ces = CsmUtilities.findCloneableEditorSupport(csmFile);
        StyledDocument stDoc = CsmUtilities.openDocument(ces);
        if (stDoc instanceof BaseDocument) {
            final BaseDocument doc = (BaseDocument) stDoc;
            doc.render(new Runnable() {
                @Override
                public void run() {
                    int offset = ref.getStartOffset();
                    TokenSequence<TokenId> cppTokenSequence = CndLexerUtilities.getCppTokenSequence(doc, offset, true, false);
                    if (cppTokenSequence == null) {
                        return;
                    }
                    CppTokenId nextImportantToken = getNextImportantToken(cppTokenSequence, offset);
                    if (nextImportantToken != null) {
                        switch (nextImportantToken) {
                            // asignments
                            case EQ:
                            case PLUSEQ:
                            case MINUSEQ:
                            case STAREQ:
                            case SLASHEQ:
                            case AMPEQ:
                            case BAREQ:
                            case CARETEQ:
                            case PERCENTEQ:
                            case LTLTEQ:
                            case GTGTEQ: {
                                CppTokenId prevImportantToken = getPreviousImportantToken(cppTokenSequence, offset);
                                if (prevImportantToken == CppTokenId.STAR) { // *x=
                                    rw = CsmRefactoringElementImpl.RW.Read;
                                    return;
                                } else { // x=
                                    rw = CsmRefactoringElementImpl.RW.Write;
                                    return;
                                }
                            }
                            // increments
                            case PLUSPLUS:
                            case MINUSMINUS: // x++
                                rw = CsmRefactoringElementImpl.RW.Write;
                                return;
                            // supose that binary operators have a read access
                            case PLUS:
                            case MINUS:
                            case GT:
                            case LT:
                            case QUESTION:
                            case EQEQ:
                            case LTEQ:
                            case GTEQ:
                            case NOTEQ:
                            case AMPAMP:
                            case BARBAR:
                            case STAR:
                            case SLASH:
                            case BAR:
                            case CARET:
                            case PERCENT:
                            case LTLT:
                            case GTGT: // x+
                                rw = CsmRefactoringElementImpl.RW.Read;
                                return;
                            case DOT:
                            case DOTMBR:
                            case ARROW:
                            case ARROWMBR:
                            case SCOPE: // x.
                                rw = CsmRefactoringElementImpl.RW.Read;
                                return;
                            case COMMA:
                            case COLON:
                            case SEMICOLON:
                            case RBRACKET:
                            case RPAREN: 
                            default: {
                                CppTokenId prevImportantToken = getPreviousImportantToken(cppTokenSequence, offset);
                                if (prevImportantToken != null) {
                                    switch (prevImportantToken) {
                                        //needs further investigation
                                        case AMP:
                                            rw = CsmRefactoringElementImpl.RW.Read;
                                            return;
                                        // increments
                                        case PLUSPLUS:
                                        case MINUSMINUS:
                                            rw = CsmRefactoringElementImpl.RW.Write;
                                            return;
                                        case EQ:
                                        case PLUSEQ:
                                        case MINUSEQ:
                                        case STAREQ:
                                        case SLASHEQ:
                                        case AMPEQ:
                                        case BAREQ:
                                        case CARETEQ:
                                        case PERCENTEQ:
                                        case LTLTEQ:
                                        case GTGTEQ:
                                            rw = CsmRefactoringElementImpl.RW.Read;
                                            return;
                                        // supose that unary operators have a read access
                                        case NOT:
                                        case TILDE:
                                            rw = CsmRefactoringElementImpl.RW.Read;
                                            return;
                                        // supose that unary/binary operators have a read access
                                        case PLUS:
                                        case MINUS:
                                            rw = CsmRefactoringElementImpl.RW.Read;
                                            return;
                                        // supose that binary operators have a read access
                                        case GT:
                                        case LT:
                                        case QUESTION:
                                        case EQEQ:
                                        case LTEQ:
                                        case GTEQ:
                                        case NOTEQ:
                                        case AMPAMP:
                                        case BARBAR:
                                        case STAR:
                                        case SLASH:
                                        case BAR:
                                        case CARET:
                                        case PERCENT:
                                        case LTLT:
                                        case GTGT:
                                            rw = CsmRefactoringElementImpl.RW.Read;
                                            return;
                                        //needs further investigation
                                        case COMMA:
                                        case LPAREN:
                                        case DOT:
                                        case DOTMBR:
                                        case ARROW:
                                        case ARROWMBR:
                                        case SCOPE:
                                            rw = CsmRefactoringElementImpl.RW.Read;
                                            return;
                                        //needs further investigation
                                        default:
                                            rw = CsmRefactoringElementImpl.RW.Read;
                                            return;
                                    }
                                }
                            }
                        }
                    }
                }
            });
        }
        return rw;
    }

    private CppTokenId getNextImportantToken(TokenSequence<TokenId> cppTokenSequence, int offset) {
        cppTokenSequence.move(offset);
        if (cppTokenSequence.moveNext()) {
            next:
            while (cppTokenSequence.moveNext()) {
                Token<TokenId> token = cppTokenSequence.token();
                TokenId id = token.id();
                if (id instanceof CppTokenId) {
                    switch ((CppTokenId) id) {
                        // skip unimportant
                        case WHITESPACE:
                        case ESCAPED_LINE:
                        case ESCAPED_WHITESPACE:
                        case NEW_LINE:
                        case LINE_COMMENT:
                        case BLOCK_COMMENT:
                        case DOXYGEN_COMMENT:
                        case DOXYGEN_LINE_COMMENT:
                            break;
                        default:
                            return (CppTokenId) id;
                    }
                }
            }
        }
        return null;
    }

    private CppTokenId getPreviousImportantToken(TokenSequence<TokenId> cppTokenSequence, int offset) {
        cppTokenSequence.move(offset);
        prev:
        while (cppTokenSequence.movePrevious()) {
            Token<TokenId> token = cppTokenSequence.token();
            TokenId id = token.id();
            if (id instanceof CppTokenId) {
                switch ((CppTokenId) id) {
                    // skip unimportant
                    case WHITESPACE:
                    case ESCAPED_LINE:
                    case ESCAPED_WHITESPACE:
                    case NEW_LINE:
                    case LINE_COMMENT:
                    case BLOCK_COMMENT:
                    case DOXYGEN_COMMENT:
                    case DOXYGEN_LINE_COMMENT:
                        break;
                    default:
                        return (CppTokenId) id;
                }
            }
        }
        return null;
    }
}

Lines 266-271 Link Here

(-)a/cnd.refactoring/src/org/netbeans/modules/cnd/refactoring/plugins/Bundle.properties (+3 lines)
266	#Find Usages Filters	266	#Find Usages Filters
267	TXT_Filter_Comments=Comments filter	267	TXT_Filter_Comments=Comments filter
268	TXT_Filter_DeadCode=Dead code filter	268	TXT_Filter_DeadCode=Dead code filter
		269	TXT_Filter_Read=Read filter
		270	TXT_Filter_Write=Write filter
		271	TXT_Filter_ReadWrite=Read/Write filter
269	TXT_Filter_Declarations=Declarations and definitions filter	272	TXT_Filter_Declarations=Declarations and definitions filter
270	TXT_Filter_Macros=Macros filter	273	TXT_Filter_Macros=Macros filter
271	TXT_Filter_Scope=Class name in qualified name filter	274	TXT_Filter_Scope=Class name in qualified name filter

Lines 50-55 Link Here

(-)a/cnd.refactoring/src/org/netbeans/modules/cnd/refactoring/plugins/CsmWhereUsedFilters.java (+3 lines)
50	COMMENTS("filter-comments"), // NOI18N	50	COMMENTS("filter-comments"), // NOI18N
51	DEAD_CODE("filter-deadcode"), // NOI18N	51	DEAD_CODE("filter-deadcode"), // NOI18N
52	MACROS("filter-macros"), // NOI18N	52	MACROS("filter-macros"), // NOI18N
		53	READ("filter-read"), // NOI18N
		54	WRITE("filter-write"), // NOI18N
		55	READ_WRITE("filter-readwrite"), // NOI18N
53	DECLARATIONS("filter-declarations"), // NOI18N	56	DECLARATIONS("filter-declarations"), // NOI18N
54	SCOPE("filter-scope"); // NOI18N	57	SCOPE("filter-scope"); // NOI18N
55		58

Lines 306-311 Link Here

(-)a/cnd.refactoring/src/org/netbeans/modules/cnd/refactoring/plugins/CsmWhereUsedQueryPlugin.java (-7 / +27 lines)
306	return refactoring.getBooleanValue(WhereUsedQueryConstants.SEARCH_FROM_BASECLASS);	306	return refactoring.getBooleanValue(WhereUsedQueryConstants.SEARCH_FROM_BASECLASS);
307	}	307	}
308		308
		309	private boolean isReadWriteAccess() {
		310	return refactoring.getBooleanValue(WhereUsedQueryConstants.READ_WRITE);
		311	}
		312
309	private boolean isSearchInComments() {	313	private boolean isSearchInComments() {
310	return refactoring.getBooleanValue(WhereUsedQuery.SEARCH_IN_COMMENTS);	314	return refactoring.getBooleanValue(WhereUsedQuery.SEARCH_IN_COMMENTS);
311	}	315	}
Lines 344-350 Link Here
344	accept = !CsmReferenceResolver.getDefault().isKindOf(csmReference, EnumSet.of(CsmReferenceKind.DECLARATION, CsmReferenceKind.DEFINITION));	348	accept = !CsmReferenceResolver.getDefault().isKindOf(csmReference, EnumSet.of(CsmReferenceKind.DECLARATION, CsmReferenceKind.DEFINITION));
345	}	349	}
346	if (accept) {	350	if (accept) {
347	elements.add(CsmRefactoringElementImpl.create(csmReference, true));	351	elements.add(CsmRefactoringElementImpl.create(csmReference, true, curObj));
348	}	352	}
349	}	353	}
350	} finally {	354	} finally {
Lines 464-469 Link Here
464	filtersDescription.addFilter(CsmWhereUsedFilters.DEAD_CODE.getKey(),	468	filtersDescription.addFilter(CsmWhereUsedFilters.DEAD_CODE.getKey(),
465	NbBundle.getMessage(this.getClass(), "TXT_Filter_DeadCode"), true,	469	NbBundle.getMessage(this.getClass(), "TXT_Filter_DeadCode"), true,
466	ImageUtilities.loadImageIcon("org/netbeans/modules/cnd/refactoring/resources/found_item_dead.png", false)); //NOI18N	470	ImageUtilities.loadImageIcon("org/netbeans/modules/cnd/refactoring/resources/found_item_dead.png", false)); //NOI18N
		471
		472	filtersDescription.addFilter(CsmWhereUsedFilters.READ.getKey(),
		473	NbBundle.getMessage(this.getClass(), "TXT_Filter_Read"), true,
		474	ImageUtilities.loadImageIcon("org/netbeans/modules/cnd/refactoring/resources/found_item_read.png", false)); //NOI18N
		475	filtersDescription.addFilter(CsmWhereUsedFilters.WRITE.getKey(),
		476	NbBundle.getMessage(this.getClass(), "TXT_Filter_Write"), true,
		477	ImageUtilities.loadImageIcon("org/netbeans/modules/cnd/refactoring/resources/found_item_write.png", false)); //NOI18N
		478	filtersDescription.addFilter(CsmWhereUsedFilters.READ_WRITE.getKey(),
		479	NbBundle.getMessage(this.getClass(), "TXT_Filter_ReadWrite"), true,
		480	ImageUtilities.loadImageIcon("org/netbeans/modules/cnd/refactoring/resources/found_item_readwrite.png", false)); //NOI18N
		481
467	filtersDescription.addFilter(CsmWhereUsedFilters.DECLARATIONS.getKey(),	482	filtersDescription.addFilter(CsmWhereUsedFilters.DECLARATIONS.getKey(),
468	NbBundle.getMessage(this.getClass(), "TXT_Filter_Declarations"), false,	483	NbBundle.getMessage(this.getClass(), "TXT_Filter_Declarations"), false,
469	ImageUtilities.loadImageIcon(CsmImageName.DECLARATION_FILTER, false));	484	ImageUtilities.loadImageIcon(CsmImageName.DECLARATION_FILTER, false));
Lines 481-486 Link Here
481	filtersDescription.enable(CsmWhereUsedFilters.COMMENTS.getKey());	496	filtersDescription.enable(CsmWhereUsedFilters.COMMENTS.getKey());
482	}	497	}
483	filtersDescription.enable(CsmWhereUsedFilters.DEAD_CODE.getKey());	498	filtersDescription.enable(CsmWhereUsedFilters.DEAD_CODE.getKey());
		499	if (isReadWriteAccess()) {
		500	filtersDescription.enable(CsmWhereUsedFilters.READ.getKey());
		501	filtersDescription.enable(CsmWhereUsedFilters.WRITE.getKey());
		502	filtersDescription.enable(CsmWhereUsedFilters.READ_WRITE.getKey());
		503	}
484	if (!isFindDirectSubclassesOnly() && !isFindSubclasses()) {	504	if (!isFindDirectSubclassesOnly() && !isFindSubclasses()) {
485	filtersDescription.enable(CsmWhereUsedFilters.DECLARATIONS.getKey());	505	filtersDescription.enable(CsmWhereUsedFilters.DECLARATIONS.getKey());
486	filtersDescription.enable(CsmWhereUsedFilters.SCOPE.getKey());	506	filtersDescription.enable(CsmWhereUsedFilters.SCOPE.getKey());
Lines 531-537 Link Here
531	accept = !CsmReferenceResolver.getDefault().isKindOf(csmReference, EnumSet.of(CsmReferenceKind.DECLARATION, CsmReferenceKind.DEFINITION));	551	accept = !CsmReferenceResolver.getDefault().isKindOf(csmReference, EnumSet.of(CsmReferenceKind.DECLARATION, CsmReferenceKind.DEFINITION));
532	}	552	}
533	if (accept) {	553	if (accept) {
534	fileElems.add(CsmRefactoringElementImpl.create(csmReference, true));	554	fileElems.add(CsmRefactoringElementImpl.create(csmReference, true, objs.length > 0 ? objs[0] : null));
535	}	555	}
536	}	556	}
537	} finally {	557	} finally {
Lines 569-581 Link Here
569	overrides.add(csmMethod);	589	overrides.add(csmMethod);
570	for (CsmMethod method : overrides) {	590	for (CsmMethod method : overrides) {
571	CsmReference declRef = CsmReferenceSupport.createObjectReference(method);	591	CsmReference declRef = CsmReferenceSupport.createObjectReference(method);
572	elements.add(CsmRefactoringElementImpl.create(declRef, false));	592	elements.add(CsmRefactoringElementImpl.create(declRef, false, method));
573	// find defintion of method if needed	593	// find defintion of method if needed
574	if (!CsmKindUtilities.isFunctionDefinition(method)) {	594	if (!CsmKindUtilities.isFunctionDefinition(method)) {
575	CsmFunctionDefinition def = method.getDefinition();	595	CsmFunctionDefinition def = method.getDefinition();
576	if (def != null) {	596	if (def != null) {
577	CsmReference defRef = CsmReferenceSupport.createObjectReference(def);	597	CsmReference defRef = CsmReferenceSupport.createObjectReference(def);
578	elements.add(CsmRefactoringElementImpl.create(defRef, false));	598	elements.add(CsmRefactoringElementImpl.create(defRef, false, method));
579	}	599	}
580	}	600	}
581	}	601	}
Lines 606-619 Link Here
606	for (CsmReference csmReference : refs) {	626	for (CsmReference csmReference : refs) {
607	for (CsmProject prj : prjs) {	627	for (CsmProject prj : prjs) {
608	if (csmReference.getContainingFile().getProject().equals(prj)) {	628	if (csmReference.getContainingFile().getProject().equals(prj)) {
609	elements.add(CsmRefactoringElementImpl.create(csmReference, false));	629	elements.add(CsmRefactoringElementImpl.create(csmReference, false, csmFile));
610	break;	630	break;
611	}	631	}
612	}	632	}
613	}	633	}
614	} else {	634	} else {
615	for (CsmReference csmReference : refs) {	635	for (CsmReference csmReference : refs) {
616	elements.add(CsmRefactoringElementImpl.create(csmReference, false));	636	elements.add(CsmRefactoringElementImpl.create(csmReference, false, csmFile));
617	}	637	}
618	}	638	}
619	}	639	}
Lines 630-636 Link Here
630	CsmClass referencedClass = (CsmClass) obj;	650	CsmClass referencedClass = (CsmClass) obj;
631	Collection<CsmReference> refs = CsmTypeHierarchyResolver.getDefault().getSubTypes(referencedClass, directSubtypesOnly);	651	Collection<CsmReference> refs = CsmTypeHierarchyResolver.getDefault().getSubTypes(referencedClass, directSubtypesOnly);
632	for (CsmReference csmReference : refs) {	652	for (CsmReference csmReference : refs) {
633	elements.add(CsmRefactoringElementImpl.create(csmReference, false));	653	elements.add(CsmRefactoringElementImpl.create(csmReference, false, startClass));
634	}	654	}
635	}	655	}
636	}	656	}




            assert panel != null;
            query.putValue(WhereUsedQuery.SEARCH_IN_COMMENTS,panel.isSearchInComments());
            
            
            Collection<CsmProject> prjs = CsmRefactoringUtils.getRelatedCsmProjects(this.origObject, panel.getScopeProject());
            CsmProject[] ar = prjs.toArray(new CsmProject[prjs.size()]);
            query.getContext().add(ar);

            query.putValue(WhereUsedQueryConstants.READ_WRITE, false);
            CsmObject refObj = panel.getReferencedObject();
            if (refObj == null) {
                query.setRefactoringSource(Lookup.EMPTY);
            } else {
                if (CsmKindUtilities.isVariable(refObj)) {
                    query.putValue(WhereUsedQueryConstants.READ_WRITE, true);
                }
                query.setRefactoringSource(Lookups.singleton(CsmRefactoringUtils.getHandler(refObj)));
            }
            if (panel.isVirtualMethod()) {

Return to bug 268402

Line 0 Link Here

(-)a/cnd.refactoring/src/org/netbeans/modules/cnd/refactoring/elements/TokenProcessor.java (+276 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright (c) 2016 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	package org.netbeans.modules.cnd.refactoring.elements;
		41
		42	import javax.swing.text.StyledDocument;
		43	import org.netbeans.api.lexer.Token;
		44	import org.netbeans.api.lexer.TokenId;
		45	import org.netbeans.api.lexer.TokenSequence;
		46	import org.netbeans.cnd.api.lexer.CndLexerUtilities;
		47	import org.netbeans.cnd.api.lexer.CppTokenId;
		48	import org.netbeans.editor.BaseDocument;
		49	import org.netbeans.modules.cnd.api.model.CsmFile;
		50	import org.netbeans.modules.cnd.api.model.xref.CsmReference;
		51	import org.netbeans.modules.cnd.modelutil.CsmUtilities;
		52	import org.openide.text.CloneableEditorSupport;
		53
		54	/**
		55	*
		56	* @author Alexander Simon
		57	*/
		58	public class TokenProcessor {
		59
		60	private final CsmReference ref;
		61	private CsmRefactoringElementImpl.RW rw = CsmRefactoringElementImpl.RW.Read;
		62
		63	TokenProcessor(CsmReference ref) {
		64	this.ref = ref;
65	}
66
67	CsmRefactoringElementImpl.RW process() {
68	CsmFile csmFile = ref.getContainingFile();
69	CloneableEditorSupport ces = CsmUtilities.findCloneableEditorSupport(csmFile);
70	StyledDocument stDoc = CsmUtilities.openDocument(ces);
71	if (stDoc instanceof BaseDocument) {
72	final BaseDocument doc = (BaseDocument) stDoc;
73	doc.render(new Runnable() {
74	@Override
75	public void run() {
76	int offset = ref.getStartOffset();
77	TokenSequence<TokenId> cppTokenSequence = CndLexerUtilities.getCppTokenSequence(doc, offset, true, false);
78	if (cppTokenSequence == null) {
79	return;
80	}
81	CppTokenId nextImportantToken = getNextImportantToken(cppTokenSequence, offset);
82	if (nextImportantToken != null) {
83	switch (nextImportantToken) {
84	// asignments
85	case EQ:
86	case PLUSEQ:
87	case MINUSEQ:
88	case STAREQ:
89	case SLASHEQ:
90	case AMPEQ:
91	case BAREQ:
92	case CARETEQ:
93	case PERCENTEQ:
94	case LTLTEQ:
95	case GTGTEQ: {
96	CppTokenId prevImportantToken = getPreviousImportantToken(cppTokenSequence, offset);
97	if (prevImportantToken == CppTokenId.STAR) { // *x=
98	rw = CsmRefactoringElementImpl.RW.Read;
99	return;
100	} else { // x=
101	rw = CsmRefactoringElementImpl.RW.Write;
102	return;
103	}
104	}
105	// increments
106	case PLUSPLUS:
107	case MINUSMINUS: // x++
108	rw = CsmRefactoringElementImpl.RW.Write;
109	return;
110	// supose that binary operators have a read access
111	case PLUS:
112	case MINUS:
113	case GT:
114	case LT:
115	case QUESTION:
116	case EQEQ:
117	case LTEQ:
118	case GTEQ:
119	case NOTEQ:
120	case AMPAMP:
121	case BARBAR:
122	case STAR:
123	case SLASH:
124	case BAR:
125	case CARET:
126	case PERCENT:
127	case LTLT:
128	case GTGT: // x+
129	rw = CsmRefactoringElementImpl.RW.Read;
130	return;
131	case DOT:
132	case DOTMBR:
133	case ARROW:
134	case ARROWMBR:
135	case SCOPE: // x.
136	rw = CsmRefactoringElementImpl.RW.Read;
137	return;
138	case COMMA:
139	case COLON:
140	case SEMICOLON:
141	case RBRACKET:
142	case RPAREN:
143	default: {
144	CppTokenId prevImportantToken = getPreviousImportantToken(cppTokenSequence, offset);
145	if (prevImportantToken != null) {
146	switch (prevImportantToken) {
147	//needs further investigation
148	case AMP:
149	rw = CsmRefactoringElementImpl.RW.Read;
150	return;
151	// increments
152	case PLUSPLUS:
153	case MINUSMINUS:
154	rw = CsmRefactoringElementImpl.RW.Write;
155	return;
156	case EQ:
157	case PLUSEQ:
158	case MINUSEQ:
159	case STAREQ:
160	case SLASHEQ:
161	case AMPEQ:
162	case BAREQ:
163	case CARETEQ:
164	case PERCENTEQ:
165	case LTLTEQ:
166	case GTGTEQ:
167	rw = CsmRefactoringElementImpl.RW.Read;
168	return;
169	// supose that unary operators have a read access
170	case NOT:
171	case TILDE:
172	rw = CsmRefactoringElementImpl.RW.Read;
173	return;
174	// supose that unary/binary operators have a read access
175	case PLUS:
176	case MINUS:
177	rw = CsmRefactoringElementImpl.RW.Read;
178	return;
179	// supose that binary operators have a read access
180	case GT:
181	case LT:
182	case QUESTION:
183	case EQEQ:
184	case LTEQ:
185	case GTEQ:
186	case NOTEQ:
187	case AMPAMP:
188	case BARBAR:
189	case STAR:
190	case SLASH:
191	case BAR:
192	case CARET:
193	case PERCENT:
194	case LTLT:
195	case GTGT:
196	rw = CsmRefactoringElementImpl.RW.Read;
197	return;
198	//needs further investigation
199	case COMMA:
200	case LPAREN:
201	case DOT:
202	case DOTMBR:
203	case ARROW:
204	case ARROWMBR:
205	case SCOPE:
206	rw = CsmRefactoringElementImpl.RW.Read;
207	return;
208	//needs further investigation
209	default:
210	rw = CsmRefactoringElementImpl.RW.Read;
211	return;
212	}
213	}
214	}
215	}
216	}
217	}
218	});
219	}
220	return rw;
221	}
222
223	private CppTokenId getNextImportantToken(TokenSequence<TokenId> cppTokenSequence, int offset) {
224	cppTokenSequence.move(offset);
225	if (cppTokenSequence.moveNext()) {
226	next:
227	while (cppTokenSequence.moveNext()) {
228	Token<TokenId> token = cppTokenSequence.token();
229	TokenId id = token.id();
230	if (id instanceof CppTokenId) {
231	switch ((CppTokenId) id) {
232	// skip unimportant
233	case WHITESPACE:
234	case ESCAPED_LINE:
235	case ESCAPED_WHITESPACE:
236	case NEW_LINE:
237	case LINE_COMMENT:
238	case BLOCK_COMMENT:
239	case DOXYGEN_COMMENT:
240	case DOXYGEN_LINE_COMMENT:
241	break;
242	default:
243	return (CppTokenId) id;
244	}
245	}
246	}
247	}
248	return null;
249	}
250
251	private CppTokenId getPreviousImportantToken(TokenSequence<TokenId> cppTokenSequence, int offset) {
252	cppTokenSequence.move(offset);
253	prev:
254	while (cppTokenSequence.movePrevious()) {
255	Token<TokenId> token = cppTokenSequence.token();
256	TokenId id = token.id();
257	if (id instanceof CppTokenId) {
258	switch ((CppTokenId) id) {
259	// skip unimportant
260	case WHITESPACE:
261	case ESCAPED_LINE:
262	case ESCAPED_WHITESPACE:
263	case NEW_LINE:
264	case LINE_COMMENT:
265	case BLOCK_COMMENT:
266	case DOXYGEN_COMMENT:
267	case DOXYGEN_LINE_COMMENT:
268	break;
269	default:
270	return (CppTokenId) id;
271	}
272	}
273	}
274	return null;
275	}
276	}

Lines 104-117 Link Here

(-)a/cnd.refactoring/src/org/netbeans/modules/cnd/refactoring/ui/WhereUsedQueryUI.java (+5 lines)
104	assert panel != null;	104	assert panel != null;
105	query.putValue(WhereUsedQuery.SEARCH_IN_COMMENTS,panel.isSearchInComments());	105	query.putValue(WhereUsedQuery.SEARCH_IN_COMMENTS,panel.isSearchInComments());
106		106
		107
107	Collection<CsmProject> prjs = CsmRefactoringUtils.getRelatedCsmProjects(this.origObject, panel.getScopeProject());	108	Collection<CsmProject> prjs = CsmRefactoringUtils.getRelatedCsmProjects(this.origObject, panel.getScopeProject());
108	CsmProject[] ar = prjs.toArray(new CsmProject[prjs.size()]);	109	CsmProject[] ar = prjs.toArray(new CsmProject[prjs.size()]);
109	query.getContext().add(ar);	110	query.getContext().add(ar);
110		111
		112	query.putValue(WhereUsedQueryConstants.READ_WRITE, false);
111	CsmObject refObj = panel.getReferencedObject();	113	CsmObject refObj = panel.getReferencedObject();
112	if (refObj == null) {	114	if (refObj == null) {
113	query.setRefactoringSource(Lookup.EMPTY);	115	query.setRefactoringSource(Lookup.EMPTY);
114	} else {	116	} else {
		117	if (CsmKindUtilities.isVariable(refObj)) {
		118	query.putValue(WhereUsedQueryConstants.READ_WRITE, true);
		119	}
115	query.setRefactoringSource(Lookups.singleton(CsmRefactoringUtils.getHandler(refObj)));	120	query.setRefactoringSource(Lookups.singleton(CsmRefactoringUtils.getHandler(refObj)));
116	}	121	}
117	if (panel.isVirtualMethod()) {	122	if (panel.isVirtualMethod()) {