diff --git a/core/org.eclipse.cdt.core.tests/ChangeLog b/core/org.eclipse.cdt.core.tests/ChangeLog index 6e418d26ac9..3bf47ea6af2 100644 --- a/core/org.eclipse.cdt.core.tests/ChangeLog +++ b/core/org.eclipse.cdt.core.tests/ChangeLog @@ -1,6 +1,14 @@ 2003-07-24 John Camelon Updated CompleteParseASTTests. +2003-07-23 Andrew Niefer + -Created search/BaseSearchTest to handle creating projects and setting them up to use the indexer + -removed ClassSpecifierSearchTests, its functionality is now in BaseSearchTest + -modified ClassDeclarationPatternTests to extend BaseSearchTest + -added FunctionMethodPatternTests + -added OtherPatternTests + -modified indexer/IndexManagerTests.testIndexContents + 2003-07-22 John Camelon Updated CompleteParseASTTests. diff --git a/core/org.eclipse.cdt.core.tests/indexer/org/eclipse/cdt/core/indexer/tests/IndexManagerTests.java b/core/org.eclipse.cdt.core.tests/indexer/org/eclipse/cdt/core/indexer/tests/IndexManagerTests.java index dce0bc4d0a5..cee69e68dba 100644 --- a/core/org.eclipse.cdt.core.tests/indexer/org/eclipse/cdt/core/indexer/tests/IndexManagerTests.java +++ b/core/org.eclipse.cdt.core.tests/indexer/org/eclipse/cdt/core/indexer/tests/IndexManagerTests.java @@ -282,7 +282,7 @@ public class IndexManagerTests extends TestCase { IIndex ind = indexManager.getIndex(testProjectPath,true,true); assertTrue("Index exists for project",ind != null); - String [] typeDeclEntryResultModel ={"EntryResult: word=typeDecl/C/Mail/Z/X/Y, refs={ 1 }","EntryResult: word=typeDecl/C/Unknown/Z/X/Y, refs={ 1 }","EntryResult: word=typeDecl/C/container/Z/X/Y, refs={ 1 }","EntryResult: word=typeDecl/C/first_class/Z/X/Y, refs={ 1 }","EntryResult: word=typeDecl/C/postcard/Z/X/Y, refs={ 1 }","EntryResult: word=typeDecl/E/test/Z/X/Y, refs={ 1 }","EntryResult: word=typeDecl/V/x/Z, refs={ 1 }"}; + String [] typeDeclEntryResultModel ={"EntryResult: word=typeDecl/C/Mail/Y/X/Z, refs={ 1 }","EntryResult: word=typeDecl/C/Unknown/Y/X/Z, refs={ 1 }","EntryResult: word=typeDecl/C/container/Y/X/Z, refs={ 1 }","EntryResult: word=typeDecl/C/first_class/Y/X/Z, refs={ 1 }","EntryResult: word=typeDecl/C/postcard/Y/X/Z, refs={ 1 }","EntryResult: word=typeDecl/E/test/Y/X/Z, refs={ 1 }","EntryResult: word=typeDecl/V/x/Z, refs={ 1 }"}; IEntryResult[] typedeclresults =ind.queryEntries(IIndexConstants.TYPE_DECL); if (typedeclresults.length != typeDeclEntryResultModel.length) @@ -304,7 +304,7 @@ public class IndexManagerTests extends TestCase { assertEquals(typeDefEntryResultModel[i],typedefresults[i].toString()); } - String [] namespaceResultModel = {"EntryResult: word=namespaceDecl/X/Z, refs={ 1 }", "EntryResult: word=namespaceDecl/Y/Z/X, refs={ 1 }", "EntryResult: word=namespaceDecl/Z, refs={ 1 }"}; + String [] namespaceResultModel = {"EntryResult: word=namespaceDecl/X/Z, refs={ 1 }", "EntryResult: word=namespaceDecl/Y/X/Z, refs={ 1 }", "EntryResult: word=namespaceDecl/Z, refs={ 1 }"}; IEntryResult[] namespaceresults =ind.queryEntries(IIndexConstants.NAMESPACE_DECL); if (namespaceresults.length != namespaceResultModel.length) @@ -315,7 +315,7 @@ public class IndexManagerTests extends TestCase { assertEquals(namespaceResultModel[i],namespaceresults[i].toString()); } - String [] fieldResultModel = {"EntryResult: word=fieldDecl/array/Z/X/Y/container, refs={ 1 }", "EntryResult: word=fieldDecl/bye/Z/X/Y/test, refs={ 1 }", "EntryResult: word=fieldDecl/cool/Z/X/Y/test, refs={ 1 }", "EntryResult: word=fieldDecl/hi/Z/X/Y/test, refs={ 1 }", "EntryResult: word=fieldDecl/index/Z/X/Y/container, refs={ 1 }", "EntryResult: word=fieldDecl/postage/Z/X/Y/Mail, refs={ 1 }", "EntryResult: word=fieldDecl/sz/Z/X/Y/container, refs={ 1 }", "EntryResult: word=fieldDecl/type/Z/X/Y/Mail, refs={ 1 }", "EntryResult: word=fieldDecl/why/Z/X/Y/test, refs={ 1 }"}; + String [] fieldResultModel = {"EntryResult: word=fieldDecl/array/container/Y/X/Z, refs={ 1 }", "EntryResult: word=fieldDecl/bye/test/Y/X/Z, refs={ 1 }", "EntryResult: word=fieldDecl/cool/test/Y/X/Z, refs={ 1 }", "EntryResult: word=fieldDecl/hi/test/Y/X/Z, refs={ 1 }", "EntryResult: word=fieldDecl/index/container/Y/X/Z, refs={ 1 }", "EntryResult: word=fieldDecl/postage/Mail/Y/X/Z, refs={ 1 }", "EntryResult: word=fieldDecl/sz/container/Y/X/Z, refs={ 1 }", "EntryResult: word=fieldDecl/type/Mail/Y/X/Z, refs={ 1 }", "EntryResult: word=fieldDecl/why/test/Y/X/Z, refs={ 1 }"}; IEntryResult[] fieldresults =ind.queryEntries(IIndexConstants.FIELD_DECL); if (fieldresults.length != fieldResultModel.length) @@ -337,7 +337,7 @@ public class IndexManagerTests extends TestCase { assertEquals(functionResultModel[i],functionresults[i].toString()); } - String [] methodResultModel = {"EntryResult: word=methodDecl/operator<Preferences>Java>Code Generation>Code and Comments + */ +public class BaseSearchTest extends TestCase implements ICSearchConstants { + + ICSearchScope scope; + IFile file; + IFileDocument fileDoc; + IProject testProject; + NullProgressMonitor monitor; + IWorkspace workspace; + CSearchResultCollector resultCollector; + SearchEngine searchEngine; + + public BaseSearchTest(String name) { + super(name); + } + + protected void setUp() throws Exception { + super.setUp(); + + monitor = new NullProgressMonitor(); + + workspace = ResourcesPlugin.getWorkspace(); + + //Create temp project + testProject = createProject("SearchTestProject"); + + if (testProject == null) + fail("Unable to create project"); + + //Add a file to the project + importFile("mail.cpp", "resources/indexer/mail.cpp"); + importFile("classDecl.cpp", "resources/search/classDecl.cpp"); + + scope = SearchEngine.createWorkspaceScope(); + + IndexManager indexManager = CCorePlugin.getDefault().getCoreModel().getIndexManager(); + indexManager.setEnabled(testProject,true); + + resultCollector = new CSearchResultCollector( true ); + resultCollector.setProgressMonitor( monitor ); + + searchEngine = new SearchEngine(); + } + + protected void tearDown() throws Exception { + super.tearDown(); + //Delete project + if (testProject.exists()){ + testProject.delete( true, monitor ); + } + } + + private IProject createProject(String projectName) throws CoreException { + IWorkspaceRoot root = workspace.getRoot(); + IProject project = root.getProject(projectName); + + if( !project.exists() ) { + project.create( null ); + } else { + project.refreshLocal(IResource.DEPTH_INFINITE, null); + } + + if( !project.isOpen() ) { + project.open( null ); + } + + //Fill out a project description + IPath defaultPath = Platform.getLocation(); + IPath newPath = project.getFullPath(); + + if (defaultPath.equals(newPath)) + newPath = null; + + IProjectDescription description = workspace.newProjectDescription(project.getName()); + + description.setLocation(newPath); + + //Create the project + IProject cproject = CCorePlugin.getDefault().createCProject( description, + project, + monitor, + CCorePlugin.PLUGIN_ID + ".make"); + + if( !project.hasNature(CProjectNature.C_NATURE_ID) ){ + addNatureToProject(project, CProjectNature.C_NATURE_ID, null); + } + + return cproject; + } + + private void importFile(String fileName, String resourceLocation)throws Exception{ + //Obtain file handle + file = testProject.getProject().getFile(fileName); + String pluginRoot=org.eclipse.core.runtime.Platform.getPlugin("org.eclipse.cdt.core.tests").find(new Path("/")).getFile(); + //Create file input stream + + if (!file.exists()){ + file.create(new FileInputStream(pluginRoot + resourceLocation),false,monitor); + } + fileDoc = new IFileDocument(file); + } + + private void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException { + IProjectDescription description = proj.getDescription(); + + String[] prevNatures = description.getNatureIds(); + String[] newNatures = new String[ prevNatures.length + 1 ]; + + System.arraycopy( prevNatures, 0, newNatures, 0, prevNatures.length ); + newNatures[ prevNatures.length ] = natureId; + description.setNatureIds( newNatures ); + proj.setDescription( description, monitor ); + } + + protected void search(IWorkspace workspace, ICSearchPattern pattern, ICSearchScope scope, ICSearchResultCollector collector) { + resultCollector.setProgressMonitor( monitor ); + searchEngine.search( workspace, pattern, scope, collector ); + } +} diff --git a/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/ClassDeclarationPatternTests.java b/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/ClassDeclarationPatternTests.java index c483322cb15..05aedd6b22f 100644 --- a/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/ClassDeclarationPatternTests.java +++ b/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/ClassDeclarationPatternTests.java @@ -22,11 +22,8 @@ import org.eclipse.cdt.core.search.SearchEngine; import org.eclipse.cdt.internal.core.search.CharOperation; import org.eclipse.cdt.internal.core.search.matching.ClassDeclarationPattern; import org.eclipse.cdt.internal.core.search.matching.MatchLocator; -import org.eclipse.cdt.internal.ui.search.CSearchResultCollector; import org.eclipse.cdt.internal.ui.search.Match; -import org.eclipse.core.runtime.Path; -import junit.framework.TestCase; /** * @author aniefer @@ -34,32 +31,22 @@ import junit.framework.TestCase; * To change the template for this generated type comment go to * Window>Preferences>Java>Code Generation>Code and Comments */ -public class ClassDeclarationPatternTests extends TestCase implements ICSearchConstants { +public class ClassDeclarationPatternTests extends BaseSearchTest implements ICSearchConstants { private MatchLocator matchLocator; - private CSearchResultCollector resultCollector; + private String cppPath; public ClassDeclarationPatternTests(String name) { super(name); } - private void initialize( ICSearchPattern pattern ){ - cppPath = org.eclipse.core.runtime.Platform.getPlugin("org.eclipse.cdt.core.tests").find(new Path("/")).getFile(); - cppPath += "resources/search/classDecl.cpp"; - - resultCollector = new CSearchResultCollector(); - matchLocator = new MatchLocator( pattern, resultCollector, null, null ); - } - public void testMatchSimpleDeclaration(){ ICSearchPattern pattern = SearchEngine.createSearchPattern( "A", TYPE, DECLARATIONS, true ); - + assertTrue( pattern instanceof ClassDeclarationPattern ); - initialize( pattern ); - - matchLocator.locateMatches( new String [] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); Set matches = resultCollector.getMatches(); assertEquals( matches.size(), 2 ); @@ -76,9 +63,7 @@ public class ClassDeclarationPatternTests extends TestCase implements ICSearchCo assertTrue( clsPattern.getContainingTypes().length == 1 ); assertTrue( CharOperation.equals( new char[] { 'N', 'S' }, clsPattern.getContainingTypes()[0] ) ); - initialize( pattern ); - - matchLocator.locateMatches( new String [] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); Set matches = resultCollector.getMatches(); assertEquals( matches.size(), 1 ); @@ -87,22 +72,22 @@ public class ClassDeclarationPatternTests extends TestCase implements ICSearchCo public void testBug39652() { ICSearchPattern pattern = SearchEngine.createSearchPattern( "A::B", TYPE, DECLARATIONS, true ); - initialize( pattern ); - matchLocator.locateMatches( new String[] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); Set matches = resultCollector.getMatches(); + /* Test should find 1 match */ assertTrue( matches != null ); assertTrue( matches.size() == 1 ); pattern = SearchEngine.createSearchPattern( "NS::NS2::a", TYPE, DECLARATIONS, true ); - initialize( pattern ); - matchLocator.locateMatches( new String[] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); + matches = resultCollector.getMatches(); assertTrue( matches != null ); pattern = SearchEngine.createSearchPattern( "NS::B::A", TYPE, DECLARATIONS, true ); - initialize( pattern ); - matchLocator.locateMatches( new String[] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); + matches = resultCollector.getMatches(); assertTrue( matches != null ); } @@ -112,19 +97,13 @@ public class ClassDeclarationPatternTests extends TestCase implements ICSearchCo assertTrue( pattern instanceof ClassDeclarationPattern ); - ClassDeclarationPattern clsPattern = (ClassDeclarationPattern) pattern; - - initialize( pattern ); - - matchLocator.locateMatches( new String[] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); Set matches = resultCollector.getMatches(); assertEquals( matches.size(), 1 ); pattern = SearchEngine.createSearchPattern( "NS::B::A", TYPE, DECLARATIONS, true ); - - initialize( pattern ); - matchLocator.locateMatches( new String[] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); Set matches2 = resultCollector.getMatches(); assertTrue( matches2 != null ); @@ -143,15 +122,13 @@ public class ClassDeclarationPatternTests extends TestCase implements ICSearchCo public void testWildcardQualification() { ICSearchPattern pattern = SearchEngine.createSearchPattern( "::*::A", TYPE, DECLARATIONS, true ); - initialize( pattern ); - matchLocator.locateMatches( new String [] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); Set matches = resultCollector.getMatches(); - assertEquals( matches, null ); + assertEquals( matches.size(), 0 ); pattern = SearchEngine.createSearchPattern( "NS::*::A", TYPE, DECLARATIONS, false ); - initialize( pattern ); - matchLocator.locateMatches( new String [] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); matches = resultCollector.getMatches(); assertEquals( matches.size(), 2 ); @@ -159,22 +136,39 @@ public class ClassDeclarationPatternTests extends TestCase implements ICSearchCo public void testElaboratedType(){ ICSearchPattern pattern = SearchEngine.createSearchPattern( "struct A", TYPE, DECLARATIONS, true ); - initialize( pattern ); - matchLocator.locateMatches( new String [] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); + Set matches = resultCollector.getMatches(); assertEquals( matches.size(), 1 ); pattern = SearchEngine.createSearchPattern( "union u", TYPE, DECLARATIONS, true ); - initialize( pattern ); - matchLocator.locateMatches( new String [] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); + matches = resultCollector.getMatches(); assertEquals( matches.size(), 2 ); pattern = SearchEngine.createSearchPattern( "union ::*::u", TYPE, DECLARATIONS, true ); - initialize( pattern ); - matchLocator.locateMatches( new String [] { cppPath }, null, null ); + search( workspace, pattern, scope, resultCollector ); + matches = resultCollector.getMatches(); assertEquals( matches.size(), 1 ); } + public void testClassIndexPrefix(){ + ICSearchPattern pattern = SearchEngine.createSearchPattern( "struct A::B::*::c", TYPE, DECLARATIONS, true ); + assertTrue( pattern instanceof ClassDeclarationPattern ); + + ClassDeclarationPattern clsPattern = (ClassDeclarationPattern)pattern; + assertEquals( CharOperation.compareWith( "typeDecl/S/c/".toCharArray(), clsPattern.indexEntryPrefix() ), 0); + + clsPattern = (ClassDeclarationPattern) SearchEngine.createSearchPattern( "class ::*::A::B::c", TYPE, DECLARATIONS, true ); + assertEquals( CharOperation.compareWith( "typeDecl/C/c/B/A/".toCharArray(), clsPattern.indexEntryPrefix() ), 0); + + clsPattern = (ClassDeclarationPattern) SearchEngine.createSearchPattern( "enum ::RT*::c", TYPE, REFERENCES, true ); + assertEquals( CharOperation.compareWith( "typeRef/E/c/RT".toCharArray(), clsPattern.indexEntryPrefix() ), 0); + + clsPattern = (ClassDeclarationPattern) SearchEngine.createSearchPattern( "union A::B::c", TYPE, REFERENCES, false ); + assertEquals( CharOperation.compareWith( "typeRef/U/".toCharArray(), clsPattern.indexEntryPrefix() ), 0); + } + } diff --git a/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/ClassSpecifierSearchTests.java b/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/ClassSpecifierSearchTests.java deleted file mode 100644 index 371714f92f0..00000000000 --- a/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/ClassSpecifierSearchTests.java +++ /dev/null @@ -1,153 +0,0 @@ -/* - * Created on Jul 11, 2003 - */ -package org.eclipse.cdt.core.search.tests; - -import java.io.FileInputStream; - -import junit.framework.Test; -import junit.framework.TestCase; -import junit.framework.TestSuite; - -import org.eclipse.cdt.core.CCorePlugin; -import org.eclipse.cdt.core.CProjectNature; -import org.eclipse.cdt.core.search.ICSearchPattern; -import org.eclipse.cdt.core.search.ICSearchResultCollector; -import org.eclipse.cdt.internal.core.index.impl.IFileDocument; -import org.eclipse.core.resources.IFile; -import org.eclipse.core.resources.IProject; -import org.eclipse.core.resources.IProjectDescription; -import org.eclipse.core.resources.IResource; -import org.eclipse.core.resources.IWorkspace; -import org.eclipse.core.resources.IWorkspaceRoot; -import org.eclipse.core.resources.ResourcesPlugin; -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IPath; -import org.eclipse.core.runtime.IProgressMonitor; -import org.eclipse.core.runtime.NullProgressMonitor; -import org.eclipse.core.runtime.Path; -import org.eclipse.core.runtime.Platform; - -/** - * @author bgheorgh - */ -public class ClassSpecifierSearchTests extends TestCase { - IFile file; - IFileDocument fileDoc; - IProject testProject; - NullProgressMonitor monitor; - - - /** - * @param name - */ - public ClassSpecifierSearchTests(String name) { - super(name); - // TODO Auto-generated constructor stub - } - - public static Test suite() { - return new TestSuite(ClassSpecifierSearchTests.class); - } - - protected void setUp() throws Exception { - super.setUp(); - //Create temp project - testProject = createProject("IndexerTestProject"); - if (testProject==null) - fail("Unable to create project"); - //Add a file to the project - importFile("mail.cpp","resources/indexer/mail.cpp"); - } - /* - * @see TestCase#tearDown() - */ - protected void tearDown() throws Exception { - super.tearDown(); - //Delete project - if (testProject.exists()){ - testProject.delete(true,monitor); - } - } - /* - * Utils - */ - private IProject createProject(String projectName) throws CoreException - { - IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot(); - IProject project= root.getProject(projectName); - if (!project.exists()) { - project.create(null); - } else { - project.refreshLocal(IResource.DEPTH_INFINITE, null); - } - if (!project.isOpen()) { - project.open(null); - } - - //Fill out a project description - IPath defaultPath = Platform.getLocation(); - IPath newPath = project.getFullPath(); - if (defaultPath.equals(newPath)) - newPath = null; - IWorkspace workspace = ResourcesPlugin.getWorkspace(); - IProjectDescription description = workspace.newProjectDescription(project.getName()); - description.setLocation(newPath); - //Create the project - IProject cproject = CCorePlugin.getDefault().createCProject(description,project,monitor,CCorePlugin.PLUGIN_ID + ".make"); //.getCoreModel().create(project); - - if (!project.hasNature(CProjectNature.C_NATURE_ID)) { - addNatureToProject(project, CProjectNature.C_NATURE_ID, null); - } - - return cproject; - } - - /** - * @param project - * @param string - * @param object - */ - private void addNatureToProject(IProject project, String string, Object object) { - // TODO Auto-generated method stub - - } - - private void importFile(String fileName, String resourceLocation)throws Exception{ - //Obtain file handle - file = testProject.getProject().getFile(fileName); - String pluginRoot=org.eclipse.core.runtime.Platform.getPlugin("org.eclipse.cdt.core.tests").find(new Path("/")).getFile(); - //Create file input stream - monitor = new NullProgressMonitor(); - if (!file.exists()){ - file.create(new FileInputStream(pluginRoot + resourceLocation),false,monitor); - } - fileDoc = new IFileDocument(file); - } - - private void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException { - IProjectDescription description = proj.getDescription(); - String[] prevNatures= description.getNatureIds(); - String[] newNatures= new String[prevNatures.length + 1]; - System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length); - newNatures[prevNatures.length]= natureId; - description.setNatureIds(newNatures); - proj.setDescription(description, monitor); - } - - public void search(ICSearchPattern pattern, ICSearchResultCollector collector){ - - } - /* - * Start of tests - */ - public void testSearchSimpleName() throws Exception { - //ICSearchPattern pattern = SearchEngine.createSearchPattern( "Mail", ICSearchConstants.TYPE, ICSearchConstants.DECLARATIONS , false ); - //Create a new result collector - //CSearchResultCollector collector= new CSearchResultCollector(); - - - } - - -} diff --git a/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/FunctionMethodPatternTests.java b/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/FunctionMethodPatternTests.java new file mode 100644 index 00000000000..3a2b20f16b2 --- /dev/null +++ b/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/FunctionMethodPatternTests.java @@ -0,0 +1,68 @@ +/******************************************************************************* + * Copyright (c) 2003 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Common Public License v0.5 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/cpl-v05.html + * + * Contributors: + * IBM Corp. - Rational Software - initial implementation + ******************************************************************************/ +/* + * Created on Jul 23, 2003 + */ +package org.eclipse.cdt.core.search.tests; + +import org.eclipse.cdt.core.search.ICSearchPattern; +import org.eclipse.cdt.core.search.SearchEngine; +import org.eclipse.cdt.internal.core.search.CharOperation; +import org.eclipse.cdt.internal.core.search.matching.FunctionDeclarationPattern; +import org.eclipse.cdt.internal.core.search.matching.MethodDeclarationPattern; + +/** + * @author aniefer + * + * To change the template for this generated type comment go to + * Window>Preferences>Java>Code Generation>Code and Comments + */ +public class FunctionMethodPatternTests extends BaseSearchTest { + + /** + * @param name + */ + public FunctionMethodPatternTests(String name) { + super(name); + // TODO Auto-generated constructor stub + } + + public void testFunctionIndexPrefix(){ + ICSearchPattern pattern = SearchEngine.createSearchPattern( "c()", FUNCTION, DECLARATIONS, true ); + assertTrue( pattern instanceof FunctionDeclarationPattern ); + + FunctionDeclarationPattern functionPattern = (FunctionDeclarationPattern)pattern; + assertEquals( CharOperation.compareWith( "functionDecl/c".toCharArray(), functionPattern.indexEntryPrefix() ), 0); + + functionPattern = (FunctionDeclarationPattern) SearchEngine.createSearchPattern( "rt*()", FUNCTION, DECLARATIONS, true ); + assertEquals( CharOperation.compareWith( "functionDecl/rt".toCharArray(), functionPattern.indexEntryPrefix() ), 0); + + functionPattern = (FunctionDeclarationPattern) SearchEngine.createSearchPattern( "Ac", FUNCTION, REFERENCES, false ); + assertEquals( CharOperation.compareWith( "functionRef/".toCharArray(), functionPattern.indexEntryPrefix() ), 0); + } + + public void testMethodIndexPrefix(){ + ICSearchPattern pattern = SearchEngine.createSearchPattern( "A::B::c", METHOD, DECLARATIONS, true ); + assertTrue( pattern instanceof MethodDeclarationPattern ); + + MethodDeclarationPattern methodPattern = (MethodDeclarationPattern)pattern; + assertEquals( CharOperation.compareWith( "methodDecl/c/B/A".toCharArray(), methodPattern.indexEntryPrefix() ), 0); + + methodPattern = (MethodDeclarationPattern) SearchEngine.createSearchPattern( "::*::A::B::c", METHOD, DECLARATIONS, true ); + assertEquals( CharOperation.compareWith( "methodDecl/c/B/A/".toCharArray(), methodPattern.indexEntryPrefix() ), 0); + + methodPattern = (MethodDeclarationPattern) SearchEngine.createSearchPattern( "::RT*::c", METHOD, REFERENCES, true ); + assertEquals( CharOperation.compareWith( "methodRef/c/RT".toCharArray(), methodPattern.indexEntryPrefix() ), 0); + + methodPattern = (MethodDeclarationPattern) SearchEngine.createSearchPattern( "A::B::c", METHOD, REFERENCES, false ); + assertEquals( CharOperation.compareWith( "methodRef/".toCharArray(), methodPattern.indexEntryPrefix() ), 0); + } +} diff --git a/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/OtherPatternTests.java b/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/OtherPatternTests.java new file mode 100644 index 00000000000..98caf3b5063 --- /dev/null +++ b/core/org.eclipse.cdt.core.tests/search/org/eclipse/cdt/core/search/tests/OtherPatternTests.java @@ -0,0 +1,87 @@ +/******************************************************************************* + * Copyright (c) 2003 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Common Public License v0.5 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/cpl-v05.html + * + * Contributors: + * IBM Corp. - Rational Software - initial implementation + ******************************************************************************/ +/* + * Created on Jul 23, 2003 + */ +package org.eclipse.cdt.core.search.tests; + +import org.eclipse.cdt.core.search.ICSearchPattern; +import org.eclipse.cdt.core.search.SearchEngine; +import org.eclipse.cdt.internal.core.search.CharOperation; +import org.eclipse.cdt.internal.core.search.matching.FieldDeclarationPattern; +import org.eclipse.cdt.internal.core.search.matching.NamespaceDeclarationPattern; +import org.eclipse.cdt.internal.core.search.matching.VariableDeclarationPattern; + +/** + * @author aniefer + * + * To change the template for this generated type comment go to + * Window>Preferences>Java>Code Generation>Code and Comments + */ +public class OtherPatternTests extends BaseSearchTest { + + /** + * @param name + */ + public OtherPatternTests(String name) { + super(name); + // TODO Auto-generated constructor stub + } + + public void testNamespaceIndexPrefix(){ + ICSearchPattern pattern = SearchEngine.createSearchPattern( "A::B::c", NAMESPACE, DECLARATIONS, true ); + assertTrue( pattern instanceof NamespaceDeclarationPattern ); + + NamespaceDeclarationPattern nsPattern = (NamespaceDeclarationPattern)pattern; + assertEquals( CharOperation.compareWith( "namespaceDecl/c/B/A".toCharArray(), nsPattern.indexEntryPrefix() ), 0); + + nsPattern = (NamespaceDeclarationPattern) SearchEngine.createSearchPattern( "::*::A::B::c", NAMESPACE, DECLARATIONS, true ); + assertEquals( CharOperation.compareWith( "namespaceDecl/c/B/A/".toCharArray(), nsPattern.indexEntryPrefix() ), 0); + + nsPattern = (NamespaceDeclarationPattern) SearchEngine.createSearchPattern( "::RT*::c", NAMESPACE, REFERENCES, true ); + assertEquals( CharOperation.compareWith( "namespaceRef/c/RT".toCharArray(), nsPattern.indexEntryPrefix() ), 0); + + nsPattern = (NamespaceDeclarationPattern) SearchEngine.createSearchPattern( "A::B::c", NAMESPACE, REFERENCES, false ); + assertEquals( CharOperation.compareWith( "namespaceRef/".toCharArray(), nsPattern.indexEntryPrefix() ), 0); + } + + public void testVariableIndexPrefix(){ + ICSearchPattern pattern = SearchEngine.createSearchPattern( "c", VAR, DECLARATIONS, true ); + assertTrue( pattern instanceof VariableDeclarationPattern ); + + VariableDeclarationPattern variablePattern = (VariableDeclarationPattern)pattern; + assertEquals( CharOperation.compareWith( "typeDecl/V/c".toCharArray(), variablePattern.indexEntryPrefix() ), 0); + + variablePattern = (VariableDeclarationPattern) SearchEngine.createSearchPattern( "rt*", VAR, DECLARATIONS, true ); + assertEquals( CharOperation.compareWith( "typeDecl/V/rt".toCharArray(), variablePattern.indexEntryPrefix() ), 0); + + variablePattern = (VariableDeclarationPattern) SearchEngine.createSearchPattern( "Ac", VAR, REFERENCES, false ); + assertEquals( CharOperation.compareWith( "typeRef/V/".toCharArray(), variablePattern.indexEntryPrefix() ), 0); + } + + public void testFieldIndexPrefix(){ + ICSearchPattern pattern = SearchEngine.createSearchPattern( "A::B::c", FIELD, DECLARATIONS, true ); + assertTrue( pattern instanceof FieldDeclarationPattern ); + + FieldDeclarationPattern fieldPattern = (FieldDeclarationPattern)pattern; + assertEquals( CharOperation.compareWith( "fieldDecl/c/B/A".toCharArray(), fieldPattern.indexEntryPrefix() ), 0); + + fieldPattern = (FieldDeclarationPattern) SearchEngine.createSearchPattern( "::*::A::B::c", FIELD, DECLARATIONS, true ); + assertEquals( CharOperation.compareWith( "fieldDecl/c/B/A/".toCharArray(), fieldPattern.indexEntryPrefix() ), 0); + + fieldPattern = (FieldDeclarationPattern) SearchEngine.createSearchPattern( "::RT*::c", FIELD, REFERENCES, true ); + assertEquals( CharOperation.compareWith( "fieldRef/c/RT".toCharArray(), fieldPattern.indexEntryPrefix() ), 0); + + fieldPattern = (FieldDeclarationPattern) SearchEngine.createSearchPattern( "A::B::c", FIELD, REFERENCES, false ); + assertEquals( CharOperation.compareWith( "fieldRef/".toCharArray(), fieldPattern.indexEntryPrefix() ), 0); + } + +} diff --git a/core/org.eclipse.cdt.core.tests/suite/org/eclipse/cdt/core/suite/AutomatedIntegrationSuite.java b/core/org.eclipse.cdt.core.tests/suite/org/eclipse/cdt/core/suite/AutomatedIntegrationSuite.java index be19815a1b4..13356e9c02a 100644 --- a/core/org.eclipse.cdt.core.tests/suite/org/eclipse/cdt/core/suite/AutomatedIntegrationSuite.java +++ b/core/org.eclipse.cdt.core.tests/suite/org/eclipse/cdt/core/suite/AutomatedIntegrationSuite.java @@ -28,6 +28,8 @@ import org.eclipse.cdt.core.parser.failedTests.LokiFailures; import org.eclipse.cdt.core.parser.failedTests.STLFailedTests; import org.eclipse.cdt.core.parser.tests.ParserTestSuite; import org.eclipse.cdt.core.search.tests.ClassDeclarationPatternTests; +import org.eclipse.cdt.core.search.tests.FunctionMethodPatternTests; +import org.eclipse.cdt.core.search.tests.OtherPatternTests; import org.eclipse.cdt.core.indexer.tests.IndexManagerTests; import org.eclipse.core.boot.IPlatformRunnable; @@ -81,6 +83,8 @@ public class AutomatedIntegrationSuite extends TestSuite suite.addTest(ElementDeltaTests.suite()); suite.addTest(WorkingCopyTests.suite()); suite.addTestSuite(ClassDeclarationPatternTests.class ); + suite.addTestSuite(FunctionMethodPatternTests.class ); + suite.addTestSuite(OtherPatternTests.class ); suite.addTest(IndexManagerTests.suite()); // Last test to trigger report generation diff --git a/core/org.eclipse.cdt.core/index/ChangeLog b/core/org.eclipse.cdt.core/index/ChangeLog index b9965cc3207..d74bd67944f 100644 --- a/core/org.eclipse.cdt.core/index/ChangeLog +++ b/core/org.eclipse.cdt.core/index/ChangeLog @@ -1,3 +1,15 @@ +2003-07-24 Andrew Niefer + Modified + *index/org/eclipse/cdt/internal/core/search/indexing/AbstractIndexer.java + -changed so that the index prefixes contain the qualified names of the + elements in reverse order. + -Added functions: + bestVariablePrefix + bestNamespacePrefix + bestFieldPrefix + bestFunctionPrefix + bestMethodPrefix + 2003-07-21 Bogdan Gheorghe Added additional declarations to index: enums, enumerators, namespace, functions, vars, methods, fields, typedefs. diff --git a/core/org.eclipse.cdt.core/index/org/eclipse/cdt/internal/core/search/indexing/AbstractIndexer.java b/core/org.eclipse.cdt.core/index/org/eclipse/cdt/internal/core/search/indexing/AbstractIndexer.java index 54bb7f905ac..ff439abb0ed 100644 --- a/core/org.eclipse.cdt.core/index/org/eclipse/cdt/internal/core/search/indexing/AbstractIndexer.java +++ b/core/org.eclipse.cdt.core/index/org/eclipse/cdt/internal/core/search/indexing/AbstractIndexer.java @@ -177,7 +177,7 @@ public abstract class AbstractIndexer implements IIndexer, IIndexConstants, ICSe pos += tempName.length; } //Extract the qualifiers - for (int i=0; i<(fullTypeName.length - 1); i++){ + for (int i=fullTypeName.length - 2; i >= 0; i--){ result[pos++] = SEPARATOR; char [] tempName = fullTypeName[i].toCharArray(); System.arraycopy(tempName, 0, result, pos, tempName.length); @@ -205,7 +205,7 @@ public abstract class AbstractIndexer implements IIndexer, IIndexConstants, ICSe pos += tempName.length; } //Extract the qualifiers - for (int i=0; i<(elementName.length - 1); i++){ + for (int i=elementName.length - 2; i>=0; i--){ result[pos++] = SEPARATOR; char [] tempName = elementName[i].toCharArray(); System.arraycopy(tempName, 0, result, pos, tempName.length); @@ -243,12 +243,7 @@ public abstract class AbstractIndexer implements IIndexer, IIndexConstants, ICSe * Type entries are encoded as follow: 'typeDecl/' ('C' | 'S' | 'U' ) '/' TypeName '/' * Current encoding is optimized for queries: all classes */ - public static final char[] bestTypeDeclarationPrefix(char[] typeName, char[][] containingTypes, ASTClassKind classKind, int matchMode, boolean isCaseSensitive) { - // index is case sensitive, thus in case attempting case insensitive search, cannot consider - // type name. - if (!isCaseSensitive){ - typeName = null; - } + public static final char[] bestTypePrefix( LimitTo limitTo, char[] typeName, char[][] containingTypes, ASTClassKind classKind, int matchMode, boolean isCaseSensitive) { //Class kind not provided, best we can do if (classKind == null){ return TYPE_DECL; @@ -261,107 +256,162 @@ public abstract class AbstractIndexer implements IIndexer, IIndexConstants, ICSe else if (classKind == ASTClassKind.UNION){ classType = UNION_SUFFIX; } + else if (classKind == ASTClassKind.ENUM){ + classType = ENUM_SUFFIX; + } - switch(matchMode){ - case EXACT_MATCH : - case PREFIX_MATCH : - break; - case PATTERN_MATCH : - if (typeName != null){ - int starPos = CharOperation.indexOf('*', typeName); - switch(starPos) { - case -1 : - break; - case 0 : - typeName = null; - break; - default : - typeName = CharOperation.subarray(typeName, 0, starPos); + char [] prefix = null; + if( limitTo == DECLARATIONS ){ + prefix = TYPE_DECL; + } else if( limitTo == REFERENCES ){ + prefix = TYPE_REF; + } + + return bestPrefix( prefix, classType, typeName, containingTypes, matchMode, isCaseSensitive ); + } + public static final char[] bestNamespacePrefix(LimitTo limitTo, char[] namespaceName, char[][] containingTypes, int matchMode, boolean isCaseSensitive) { + char [] prefix = null; + if( limitTo == REFERENCES ){ + prefix = NAMESPACE_REF; + } else { + prefix = NAMESPACE_DECL; + } + return bestPrefix( prefix, (char) 0, namespaceName, containingTypes, matchMode, isCaseSensitive ); + } + + public static final char[] bestVariablePrefix( LimitTo limitTo, char[] varName, int matchMode, boolean isCaseSenstive ){ + char [] prefix = null; + if( limitTo == REFERENCES ){ + prefix = TYPE_REF; + } else { + prefix = TYPE_DECL; + } + + return bestPrefix( prefix, VAR_SUFFIX, varName, null, matchMode, isCaseSenstive ); + } + + public static final char[] bestFieldPrefix( LimitTo limitTo, char[] fieldName,char[][] containingTypes, int matchMode, boolean isCaseSensitive) { + char [] prefix = null; + if( limitTo == REFERENCES ){ + prefix = FIELD_REF; + } else { + prefix = FIELD_DECL; + } + return bestPrefix( prefix, (char)0, fieldName, containingTypes, matchMode, isCaseSensitive ); + } + + public static final char[] bestMethodPrefix( LimitTo limitTo, char[] methodName,char[][] containingTypes, int matchMode, boolean isCaseSensitive) { + char [] prefix = null; + if( limitTo == REFERENCES ){ + prefix = METHOD_REF; + } else { + prefix = METHOD_DECL; + } + return bestPrefix( prefix, (char)0, methodName, containingTypes, matchMode, isCaseSensitive ); + } + + public static final char[] bestFunctionPrefix( LimitTo limitTo, char[] functionName, int matchMode, boolean isCaseSensitive) { + char [] prefix = null; + if( limitTo == REFERENCES ){ + prefix = FUNCTION_REF; + } else { + prefix = FUNCTION_DECL; + } + return bestPrefix( prefix, (char)0, functionName, null, matchMode, isCaseSensitive ); + } + + public static final char[] bestPrefix( char [] prefix, char optionalType, char[] name, char[][] containingTypes, int matchMode, boolean isCaseSensitive) { + char[] result = null; + int pos = 0; + + //length of prefix + separator + int length = prefix.length; + + //add length for optional type + another separator + if( optionalType != 0 ) + length += 2; + + if (!isCaseSensitive){ + //index is case sensitive, thus in case attempting case insensitive search, cannot consider + //type name. + name = null; + } else if( matchMode == PATTERN_MATCH && name != null ){ + int starPos = CharOperation.indexOf( '*', name ); + switch( starPos ){ + case -1 : break; + case 0 : name = null; + default : name = CharOperation.subarray( name, 0, starPos ); + } + } + //add length for name + if( name != null ){ + length += name.length; + } else { + //name is null, don't even consider qualifications. + result = new char [ length ]; + System.arraycopy( prefix, 0, result, 0, pos = prefix.length ); + if( optionalType != 0){ + result[ pos++ ] = optionalType; + result[ pos++ ] = SEPARATOR; + } + return result; + } + + //add the total length of the qualifiers + //we don't want to mess with the contents of this array (treat it as constant) + //so check for wild cards later. + if( containingTypes != null ){ + for( int i = 0; i < containingTypes.length; i++ ){ + if( containingTypes[i].length > 0 ){ + length += containingTypes[ i ].length; + length++; //separator + } + } + } + + //because we haven't checked qualifier wild cards yet, this array might turn out + //to be too long. So fill a temp array, then check the length after + char [] temp = new char [ length ]; + + System.arraycopy( prefix, 0, temp, 0, pos = prefix.length ); + + if( optionalType != 0 ){ + temp[ pos++ ] = optionalType; + temp[ pos++ ] = SEPARATOR; + } + + System.arraycopy( name, 0, temp, pos, name.length ); + pos += name.length; + + if( containingTypes != null ){ + for( int i = containingTypes.length - 1; i >= 0; i-- ){ + if( matchMode == PATTERN_MATCH ){ + int starPos = CharOperation.indexOf( '*', containingTypes[i] ); + if( starPos >= 0 ){ + temp[ pos++ ] = SEPARATOR; + System.arraycopy( containingTypes[i], 0, temp, pos, starPos ); + pos += starPos; + break; } } - } - - int containingTypesLength=0; - int typeLength = typeName == null ? 0 : typeName.length; - int pos; - //figure out the total length of the qualifiers - for (int i=0; i 0){ - System.arraycopy(typeName, 0, result, pos, typeName.length); - pos += typeName.length; - } - for (int i=0; i 0 ){ + temp[ pos++ ] = SEPARATOR; + System.arraycopy( containingTypes[i], 0, temp, pos, containingTypes[i].length ); + pos += containingTypes[i].length; + } + } + } + + if( pos < length ){ + result = new char[ pos ]; + System.arraycopy( temp, 0, result, 0, pos ); + } else { + result = temp; } return result; - } - - public static final char[] bestNamespacePrefix(char[] namespaceName, char[][] containingTypes, int matchMode, boolean isCaseSensitive) { - // index is case sensitive, thus in case attempting case insensitive search, cannot consider - // type name. - if (!isCaseSensitive){ - namespaceName = null; - } - - switch(matchMode){ - case EXACT_MATCH : - case PREFIX_MATCH : - break; - case PATTERN_MATCH : - if (namespaceName != null){ - int starPos = CharOperation.indexOf('*', namespaceName); - switch(starPos) { - case -1 : - break; - case 0 : - namespaceName = null; - break; - default : - namespaceName = CharOperation.subarray(namespaceName, 0, starPos); - } - } - } - - int containingTypesLength=0; - int typeLength = namespaceName == null ? 0 : namespaceName.length; - int pos; - //figure out the total length of the qualifiers - for (int i=0; i 0){ - System.arraycopy(namespaceName, 0, result, pos, namespaceName.length); - pos += namespaceName.length; - } - - for (int i=0; i 0 ) + param += " "; + param += token.getImage(); + break; + } + + token = scanner.nextToken(); + } + } catch ( EndOfFile e ){ + list.addLast( param.toCharArray() ); + } catch( ScannerException e ){ + } + + return list; + } + static private LinkedList scanForNames( IScanner scanner, IToken unusedToken ){ LinkedList list = new LinkedList(); @@ -219,6 +303,8 @@ public abstract class CSearchPattern implements ICSearchConstants, ICSearchPatte try { IToken token = ( unusedToken != null ) ? unusedToken : scanner.nextToken(); + boolean lastTokenWasWild = false; + while( true ){ switch( token.getType() ){ case IToken.tCOLONCOLON : @@ -226,12 +312,12 @@ public abstract class CSearchPattern implements ICSearchConstants, ICSearchPatte name = new String(""); break; default: - if( token.getType() != IToken.tSTAR && - token.getType() != IToken.tQUESTION && - name.length() > 0 ) - { + if( token.getType() == IToken.tSTAR || token.getType() == IToken.tQUESTION ){ + lastTokenWasWild = true; + } else if( !lastTokenWasWild && name.length() > 0 ) { name += " "; } + name += token.getImage(); break; } diff --git a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/ClassDeclarationPattern.java b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/ClassDeclarationPattern.java index 834a439043d..46a90eb8b16 100644 --- a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/ClassDeclarationPattern.java +++ b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/ClassDeclarationPattern.java @@ -15,11 +15,12 @@ package org.eclipse.cdt.internal.core.search.matching; import java.io.IOException; +import org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate; import org.eclipse.cdt.core.parser.ast.ASTClassKind; import org.eclipse.cdt.core.parser.ast.IASTClassSpecifier; import org.eclipse.cdt.core.parser.ast.IASTEnumerationSpecifier; -import org.eclipse.cdt.core.parser.ast.IASTOffsetableElement; import org.eclipse.cdt.core.parser.ast.IASTOffsetableNamedElement; +import org.eclipse.cdt.core.parser.ast.IASTQualifiedNameElement; import org.eclipse.cdt.core.search.ICSearchScope; import org.eclipse.cdt.internal.core.index.IEntryResult; import org.eclipse.cdt.internal.core.index.impl.IndexInput; @@ -57,7 +58,7 @@ public class ClassDeclarationPattern extends CSearchPattern { limitTo = limit; } - public int matchLevel( IASTOffsetableElement node ){ + public int matchLevel( ISourceElementCallbackDelegate node ){ if( !( node instanceof IASTClassSpecifier ) && !( node instanceof IASTEnumerationSpecifier ) ) return IMPOSSIBLE_MATCH; @@ -69,14 +70,7 @@ public class ClassDeclarationPattern extends CSearchPattern { return IMPOSSIBLE_MATCH; } - String [] fullyQualifiedName = null; - - if( node instanceof IASTClassSpecifier ){ - IASTClassSpecifier clsSpec = (IASTClassSpecifier) node; - fullyQualifiedName = clsSpec.getFullyQualifiedName(); - } else { - //TODO fully qualified names for enums - } + String [] fullyQualifiedName = ((IASTQualifiedNameElement) node).getFullyQualifiedName(); //check containing scopes if( !matchQualifications( containingTypes, fullyQualifiedName ) ){ @@ -151,7 +145,8 @@ public class ClassDeclarationPattern extends CSearchPattern { } public char[] indexEntryPrefix() { - return AbstractIndexer.bestTypeDeclarationPrefix( + return AbstractIndexer.bestTypePrefix( + limitTo, simpleName, containingTypes, classKind, diff --git a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/FieldDeclarationPattern.java b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/FieldDeclarationPattern.java index 7144a208de7..6cb9ce027bf 100644 --- a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/FieldDeclarationPattern.java +++ b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/FieldDeclarationPattern.java @@ -13,6 +13,11 @@ */ package org.eclipse.cdt.internal.core.search.matching; +import org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate; +import org.eclipse.cdt.core.parser.ast.IASTField; +import org.eclipse.cdt.core.parser.ast.IASTQualifiedNameElement; +import org.eclipse.cdt.internal.core.search.indexing.AbstractIndexer; + /** * @author aniefer @@ -29,9 +34,37 @@ public class FieldDeclarationPattern extends VariableDeclarationPattern { * @param limitTo * @param caseSensitive */ - public FieldDeclarationPattern(char[] name, char[][] cs, int matchMode, LimitTo limitTo, boolean caseSensitive) { + public FieldDeclarationPattern(char[] name, char[][] qual, int matchMode, LimitTo limitTo, boolean caseSensitive) { super( name, matchMode, limitTo, caseSensitive ); - // TODO Auto-generated constructor stub + qualifications = qual; } + + public int matchLevel(ISourceElementCallbackDelegate node) { + if( !(node instanceof IASTField) ){ + return IMPOSSIBLE_MATCH; + } + + if( super.matchLevel( node ) == IMPOSSIBLE_MATCH ){ + return IMPOSSIBLE_MATCH; + } + + //check containing scopes + String [] fullyQualifiedName = ((IASTQualifiedNameElement) node).getFullyQualifiedName(); + if( !matchQualifications( qualifications, fullyQualifiedName ) ){ + return IMPOSSIBLE_MATCH; + } + + return ACCURATE_MATCH; + } + + public char[] indexEntryPrefix() { + return AbstractIndexer.bestFieldPrefix( _limitTo, simpleName, qualifications, _matchMode, _caseSensitive ); + } + + protected boolean matchIndexEntry() { + return true; + } + + private char [][] qualifications; } diff --git a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/FunctionDeclarationPattern.java b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/FunctionDeclarationPattern.java index d753b4d5642..97f7a67baf5 100644 --- a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/FunctionDeclarationPattern.java +++ b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/FunctionDeclarationPattern.java @@ -14,12 +14,19 @@ package org.eclipse.cdt.internal.core.search.matching; import java.io.IOException; +import java.util.Iterator; -import org.eclipse.cdt.core.parser.ast.IASTOffsetableElement; +import org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate; +import org.eclipse.cdt.core.parser.ast.IASTFunction; +import org.eclipse.cdt.core.parser.ast.IASTOffsetableNamedElement; +import org.eclipse.cdt.core.parser.ast.IASTParameterDeclaration; +import org.eclipse.cdt.core.parser.ast.IASTSimpleTypeSpecifier; +import org.eclipse.cdt.core.parser.ast.IASTTypeSpecifier; import org.eclipse.cdt.core.search.ICSearchScope; import org.eclipse.cdt.internal.core.index.IEntryResult; import org.eclipse.cdt.internal.core.index.impl.IndexInput; import org.eclipse.cdt.internal.core.search.IIndexSearchRequestor; +import org.eclipse.cdt.internal.core.search.indexing.AbstractIndexer; /** * @author aniefer @@ -29,14 +36,67 @@ import org.eclipse.cdt.internal.core.search.IIndexSearchRequestor; */ public class FunctionDeclarationPattern extends CSearchPattern { + protected char[][] parameterNames; + + protected char[] simpleName; + + public FunctionDeclarationPattern(char[] name, char [][] params, int matchMode, LimitTo limitTo, boolean caseSensitive) { + super( matchMode, caseSensitive, limitTo ); + + simpleName = name; + parameterNames = params; + } + /* (non-Javadoc) * @see org.eclipse.cdt.core.search.ICSearchPattern#matchLevel(org.eclipse.cdt.core.parser.ast.IASTOffsetableElement) */ - public int matchLevel(IASTOffsetableElement node) { - // TODO Auto-generated method stub - return 0; + public int matchLevel(ISourceElementCallbackDelegate node) { + if( !( node instanceof IASTFunction ) ) + return IMPOSSIBLE_MATCH; + + IASTFunction function = (IASTFunction) node; + String nodeName = function.getName(); + + //check name, if simpleName == null, its treated the same as "*" + if( simpleName != null && !matchesName( simpleName, nodeName.toCharArray() ) ){ + return IMPOSSIBLE_MATCH; + } + + if( parameterNames != null ){ + Iterator params = function.getParameters(); + + + for( int i = 0; i < parameterNames.length; i++ ){ + + //if this function doesn't have this many parameters, it is not a match. + //or if this function has a parameter, but parameterNames only has null. + if( !params.hasNext() || parameterNames[ i ] == null ) + return IMPOSSIBLE_MATCH; + + IASTParameterDeclaration param = (IASTParameterDeclaration) params.next(); + IASTTypeSpecifier typeSpec = param.getTypeSpecifier(); + String paramName = null; + if( typeSpec instanceof IASTSimpleTypeSpecifier ){ + paramName = ((IASTSimpleTypeSpecifier)typeSpec).getTypename(); + } else if( typeSpec instanceof IASTOffsetableNamedElement ){ + paramName = ((IASTOffsetableNamedElement)typeSpec).getName(); + } else { + //??? + return IMPOSSIBLE_MATCH; + } + + if( !matchesName( parameterNames[i], paramName.toCharArray() ) ) + return IMPOSSIBLE_MATCH; + } + //if this function still has more parameters, it is not a match + if( params.hasNext() ) + return IMPOSSIBLE_MATCH; + } + + return ACCURATE_MATCH; } + /* (non-Javadoc) * @see org.eclipse.cdt.internal.core.search.matching.CSearchPattern#feedIndexRequestor(org.eclipse.cdt.internal.core.search.IIndexSearchRequestor, int, int[], org.eclipse.cdt.internal.core.index.impl.IndexInput, org.eclipse.cdt.core.search.ICSearchScope) */ @@ -57,16 +117,14 @@ public class FunctionDeclarationPattern extends CSearchPattern { * @see org.eclipse.cdt.internal.core.search.matching.CSearchPattern#indexEntryPrefix() */ public char[] indexEntryPrefix() { - // TODO Auto-generated method stub - return null; + return AbstractIndexer.bestFunctionPrefix( _limitTo, simpleName, _matchMode, _caseSensitive ); } /* (non-Javadoc) * @see org.eclipse.cdt.internal.core.search.matching.CSearchPattern#matchIndexEntry() */ protected boolean matchIndexEntry() { - // TODO Auto-generated method stub - return false; + return true; } } diff --git a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/MatchLocator.java b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/MatchLocator.java index 2333e1781e8..704fc2a1f2c 100644 --- a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/MatchLocator.java +++ b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/MatchLocator.java @@ -19,48 +19,17 @@ import java.io.InputStreamReader; import java.io.Reader; import java.util.Arrays; import java.util.HashMap; +import java.util.Iterator; import java.util.LinkedList; import org.eclipse.cdt.core.parser.IParser; import org.eclipse.cdt.core.parser.IProblem; import org.eclipse.cdt.core.parser.IScanner; +import org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate; import org.eclipse.cdt.core.parser.ISourceElementRequestor; import org.eclipse.cdt.core.parser.ParserFactory; import org.eclipse.cdt.core.parser.ParserMode; -import org.eclipse.cdt.core.parser.ast.ASTClassKind; -import org.eclipse.cdt.core.parser.ast.IASTASMDefinition; -import org.eclipse.cdt.core.parser.ast.IASTAbstractTypeSpecifierDeclaration; -import org.eclipse.cdt.core.parser.ast.IASTClassReference; -import org.eclipse.cdt.core.parser.ast.IASTClassSpecifier; -import org.eclipse.cdt.core.parser.ast.IASTCompilationUnit; -import org.eclipse.cdt.core.parser.ast.IASTElaboratedTypeSpecifier; -import org.eclipse.cdt.core.parser.ast.IASTEnumerationReference; -import org.eclipse.cdt.core.parser.ast.IASTEnumerationSpecifier; -import org.eclipse.cdt.core.parser.ast.IASTEnumerator; -import org.eclipse.cdt.core.parser.ast.IASTField; -import org.eclipse.cdt.core.parser.ast.IASTFieldReference; -import org.eclipse.cdt.core.parser.ast.IASTFunction; -import org.eclipse.cdt.core.parser.ast.IASTFunctionReference; -import org.eclipse.cdt.core.parser.ast.IASTInclusion; -import org.eclipse.cdt.core.parser.ast.IASTLinkageSpecification; -import org.eclipse.cdt.core.parser.ast.IASTMacro; -import org.eclipse.cdt.core.parser.ast.IASTMethod; -import org.eclipse.cdt.core.parser.ast.IASTMethodReference; -import org.eclipse.cdt.core.parser.ast.IASTNamespaceDefinition; -import org.eclipse.cdt.core.parser.ast.IASTNamespaceReference; -import org.eclipse.cdt.core.parser.ast.IASTOffsetableNamedElement; -import org.eclipse.cdt.core.parser.ast.IASTPointerToFunction; -import org.eclipse.cdt.core.parser.ast.IASTPointerToMethod; -import org.eclipse.cdt.core.parser.ast.IASTScope; -import org.eclipse.cdt.core.parser.ast.IASTTemplateDeclaration; -import org.eclipse.cdt.core.parser.ast.IASTTemplateInstantiation; -import org.eclipse.cdt.core.parser.ast.IASTTemplateSpecialization; -import org.eclipse.cdt.core.parser.ast.IASTTypedefDeclaration; -import org.eclipse.cdt.core.parser.ast.IASTTypedefReference; -import org.eclipse.cdt.core.parser.ast.IASTUsingDeclaration; -import org.eclipse.cdt.core.parser.ast.IASTUsingDirective; -import org.eclipse.cdt.core.parser.ast.IASTVariable; -import org.eclipse.cdt.core.parser.ast.IASTVariableReference; +import org.eclipse.cdt.core.parser.ast.*; import org.eclipse.cdt.core.search.ICSearchConstants; import org.eclipse.cdt.core.search.ICSearchPattern; import org.eclipse.cdt.core.search.ICSearchResultCollector; @@ -86,7 +55,6 @@ import org.eclipse.core.runtime.Path; */ public class MatchLocator implements ISourceElementRequestor, ICSearchConstants { - /** * */ @@ -100,97 +68,122 @@ public class MatchLocator implements ISourceElementRequestor, ICSearchConstants public void acceptProblem(IProblem problem) { } public void acceptMacro(IASTMacro macro) { } - public void acceptVariable(IASTVariable variable) { } - public void acceptFunctionDeclaration(IASTFunction function) { } public void acceptUsingDirective(IASTUsingDirective usageDirective) { } public void acceptUsingDeclaration(IASTUsingDeclaration usageDeclaration) { } public void acceptASMDefinition(IASTASMDefinition asmDefinition) { } - public void acceptTypedefDeclaration(IASTTypedefDeclaration typedef) { } - public void acceptEnumerator(IASTEnumerator enumerator) { } + public void acceptTypedefDeclaration(IASTTypedefDeclaration typedef) { } + public void acceptAbstractTypeSpecDeclaration(IASTAbstractTypeSpecifierDeclaration abstractDeclaration) {} public void acceptPointerToFunction(IASTPointerToFunction function) {} public void acceptPointerToMethod(IASTPointerToMethod method) { } + public void acceptTypedefReference( IASTTypedefReference reference ) { } - public void acceptEnumerationSpecifier(IASTEnumerationSpecifier enumeration){ - if( searchPattern.getLimitTo() == DECLARATIONS || searchPattern.getLimitTo() == ALL_OCCURRENCES ){ - if( searchPattern instanceof ClassDeclarationPattern ){ - ClassDeclarationPattern classPattern = (ClassDeclarationPattern)searchPattern; - if( classPattern.getKind() == null || classPattern.getKind() == ASTClassKind.ENUM ){ - int level = searchPattern.matchLevel( enumeration ); - if( level != ICSearchPattern.IMPOSSIBLE_MATCH ){ - report( enumeration, level ); - } - } - } - } - } + public void enterLinkageSpecification(IASTLinkageSpecification linkageSpec) { } + public void enterTemplateDeclaration(IASTTemplateDeclaration declaration) { } + public void enterTemplateSpecialization(IASTTemplateSpecialization specialization) { } + public void enterTemplateInstantiation(IASTTemplateInstantiation instantiation) { } + + public void exitTemplateDeclaration(IASTTemplateDeclaration declaration) {} + public void exitTemplateSpecialization(IASTTemplateSpecialization specialization) { } + public void exitTemplateExplicitInstantiation(IASTTemplateInstantiation instantiation) { } + public void exitLinkageSpecification(IASTLinkageSpecification linkageSpec) { } - public void acceptClassReference(IASTClassReference reference) { } - public void acceptTypedefReference( IASTTypedefReference reference ){ } - public void acceptNamespaceReference( IASTNamespaceReference reference ){ } - public void acceptEnumerationReference( IASTEnumerationReference reference ){ } - public void acceptVariableReference( IASTVariableReference reference ){ } - public void acceptFunctionReference( IASTFunctionReference reference ){ } - public void acceptFieldReference( IASTFieldReference reference ){ } - public void acceptMethodReference( IASTMethodReference reference ) { } + public void acceptVariable(IASTVariable variable){ + check( DECLARATIONS, VariableDeclarationPattern.class, variable ); + } - public void acceptMethodDeclaration(IASTMethod method) { } - public void acceptField(IASTField field) { } + public void acceptField(IASTField field){ + check( DECLARATIONS, FieldDeclarationPattern.class, field ); + } + + public void acceptEnumerationSpecifier(IASTEnumerationSpecifier enumeration){ + check( DECLARATIONS, ClassDeclarationPattern.class, enumeration ); + Iterator iter = enumeration.getEnumerators(); + while( iter.hasNext() ){ + check ( DECLARATIONS, FieldDeclarationPattern.class, (ISourceElementCallbackDelegate) iter.next() ); + } + } + + public void acceptFunctionDeclaration(IASTFunction function){ + check( DECLARATIONS, FunctionDeclarationPattern.class, function ); + } + + public void acceptMethodDeclaration(IASTMethod method){ + check( DECLARATIONS, MethodDeclarationPattern.class, method ); + } + + public void acceptClassReference(IASTClassReference reference) { + check( REFERENCES, ClassDeclarationPattern.class, reference ); + } + + public void acceptNamespaceReference( IASTNamespaceReference reference ){ + check( REFERENCES, NamespaceDeclarationPattern.class, reference ); + } + + public void acceptVariableReference( IASTVariableReference reference ){ + check( REFERENCES, VariableDeclarationPattern.class, reference ); + } + + public void acceptFieldReference( IASTFieldReference reference ){ + check( REFERENCES, FieldDeclarationPattern.class, reference ); + } + + public void acceptEnumerationReference( IASTEnumerationReference reference ){ + check( REFERENCES, ClassDeclarationPattern.class, reference ); + } + + public void acceptFunctionReference( IASTFunctionReference reference ){ + check( REFERENCES, FunctionDeclarationPattern.class, reference ); + } + + public void acceptMethodReference( IASTMethodReference reference ){ + check( REFERENCES, MethodDeclarationPattern.class, reference ); + } public void enterFunctionBody(IASTFunction function){ + check( DEFINITIONS, FunctionDeclarationPattern.class, function ); pushScope( function ); } + public void enterMethodBody(IASTMethod method) { + check( DEFINITIONS, MethodDeclarationPattern.class, method ); + pushScope( method ); + } + public void enterCompilationUnit(IASTCompilationUnit compilationUnit) { pushScope( compilationUnit ); } public void enterNamespaceDefinition(IASTNamespaceDefinition namespaceDefinition) { - if( searchPattern.getLimitTo() == DECLARATIONS || searchPattern.getLimitTo() == ALL_OCCURRENCES ){ - if( searchPattern instanceof NamespaceDeclarationPattern ){ - int level = searchPattern.matchLevel( namespaceDefinition ); - if( level != ICSearchPattern.IMPOSSIBLE_MATCH ){ - report( namespaceDefinition, level ); - } - } - } - + check( DECLARATIONS, NamespaceDeclarationPattern.class, namespaceDefinition ); pushScope( namespaceDefinition ); } - - public void enterLinkageSpecification(IASTLinkageSpecification linkageSpec) { } - public void enterTemplateDeclaration(IASTTemplateDeclaration declaration) { } - public void enterTemplateSpecialization(IASTTemplateSpecialization specialization) { } - public void enterTemplateInstantiation(IASTTemplateInstantiation instantiation) { } - - public void enterMethodBody(IASTMethod method) { - pushScope( method ); + + public void enterClassSpecifier(IASTClassSpecifier classSpecification) { + check( DECLARATIONS, ClassDeclarationPattern.class, classSpecification ); + pushScope( classSpecification ); } public void exitFunctionBody(IASTFunction function) { popScope(); } + public void exitMethodBody(IASTMethod method) { popScope(); } - - public void exitTemplateDeclaration(IASTTemplateDeclaration declaration) {} - public void exitTemplateSpecialization(IASTTemplateSpecialization specialization) { } - public void exitTemplateExplicitInstantiation(IASTTemplateInstantiation instantiation) { } - public void exitLinkageSpecification(IASTLinkageSpecification linkageSpec) { } - + public void exitClassSpecifier(IASTClassSpecifier classSpecification) { popScope(); } - + public void exitNamespaceDefinition(IASTNamespaceDefinition namespaceDefinition) { popScope(); } - + public void exitCompilationUnit(IASTCompilationUnit compilationUnit){ popScope(); } - + public void enterInclusion(IASTInclusion inclusion) { String includePath = inclusion.getFullFileName(); @@ -227,17 +220,6 @@ public class MatchLocator implements ISourceElementRequestor, ICSearchConstants } } - public void enterClassSpecifier(IASTClassSpecifier classSpecification) { - if( searchPattern.getLimitTo() == DECLARATIONS || searchPattern.getLimitTo() == ALL_OCCURRENCES ){ - if( searchPattern instanceof ClassDeclarationPattern ){ - int level = searchPattern.matchLevel( classSpecification ); - if( level != ICSearchPattern.IMPOSSIBLE_MATCH ){ - report( classSpecification, level ); - } - } - } - pushScope( classSpecification ); - } public void locateMatches( String [] paths, IWorkspace workspace, IWorkingCopy[] workingCopies ){ workspaceRoot = (workspace != null) ? workspace.getRoot() : null; @@ -269,8 +251,12 @@ public class MatchLocator implements ISourceElementRequestor, ICSearchConstants } for( int i = 0; i < length; i++ ){ - if( progressMonitor != null && progressMonitor.isCanceled() ){ - throw new OperationCanceledException(); + if( progressMonitor != null ) { + if( progressMonitor.isCanceled() ){ + throw new OperationCanceledException(); + } else { + progressMonitor.worked( 1 ); + } } String pathString = paths[ i ]; @@ -318,37 +304,59 @@ public class MatchLocator implements ISourceElementRequestor, ICSearchConstants } } - protected void report( IASTOffsetableNamedElement node, int accuracyLevel ){ + protected void report( ISourceElementCallbackDelegate node, int accuracyLevel ){ try { - if( progressMonitor != null ) { - if( progressMonitor.isCanceled() ) { - throw new OperationCanceledException(); - } else { - progressMonitor.worked( 1 ); - } - } + int offset = 0; + int length = 0; - int offset = node.getNameOffset(); - if( offset == 0 ) - offset = node.getStartingOffset(); - + if( node instanceof IASTReference ){ + IASTReference reference = (IASTReference) node; + offset = reference.getOffset(); + length = reference.getName().length(); + } else if( node instanceof IASTOffsetableNamedElement ){ + IASTOffsetableNamedElement offsetableElement = (IASTOffsetableNamedElement) node; + offset = offsetableElement.getNameOffset() != 0 ? offsetableElement.getNameOffset() + : offsetableElement.getStartingOffset(); + length = offsetableElement.getName().length(); + } + if( currentResource != null ){ resultCollector.accept( currentResource, - offset, - offset + node.getName().length(), - resultCollector.createMatch( node, currentScope ), - accuracyLevel ); + offset, + offset + length, + resultCollector.createMatch( node, currentScope ), + accuracyLevel ); + } else if( currentPath != null ){ + resultCollector.accept( currentPath, offset, - offset + node.getName().length(), + offset + length, resultCollector.createMatch( node, currentScope ), accuracyLevel ); } } catch (CoreException e) { - // TODO Auto-generated catch block - e.printStackTrace(); + } + } + + private void check( LimitTo limit, Class patternClass, ISourceElementCallbackDelegate node ){ + if( searchPattern.getLimitTo() != limit && searchPattern.getLimitTo() != ALL_OCCURRENCES ) + return; + + if( searchPattern.getClass() == patternClass ){ + int level = ICSearchPattern.IMPOSSIBLE_MATCH; + + if( node instanceof IASTReference ){ + level = searchPattern.matchLevel( ((IASTReference)node).getReferencedElement() ); + } else { + level = searchPattern.matchLevel( node ); + } + + if( level != ICSearchPattern.IMPOSSIBLE_MATCH ) + { + report( node, level ); + } } } @@ -376,4 +384,5 @@ public class MatchLocator implements ISourceElementRequestor, ICSearchConstants private IASTScope currentScope = null; private LinkedList scopeStack = new LinkedList(); + } diff --git a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/MethodDeclarationPattern.java b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/MethodDeclarationPattern.java index edad50159ad..ad947eaeffe 100644 --- a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/MethodDeclarationPattern.java +++ b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/MethodDeclarationPattern.java @@ -13,6 +13,10 @@ */ package org.eclipse.cdt.internal.core.search.matching; +import org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate; +import org.eclipse.cdt.core.parser.ast.*; +import org.eclipse.cdt.internal.core.search.indexing.AbstractIndexer; + /** * @author aniefer * @@ -21,4 +25,38 @@ package org.eclipse.cdt.internal.core.search.matching; */ public class MethodDeclarationPattern extends FunctionDeclarationPattern { + private char[][] qualifications; + + + public MethodDeclarationPattern(char[] name, char[][] qual, char [][] params, int matchMode, LimitTo limitTo, boolean caseSensitive) { + super( name, params, matchMode, limitTo, caseSensitive ); + qualifications = qual; + } + + + public int matchLevel(ISourceElementCallbackDelegate node) { + if( !(node instanceof IASTMethod) ){ + return IMPOSSIBLE_MATCH; + } + + if( super.matchLevel( node ) == IMPOSSIBLE_MATCH ){ + return IMPOSSIBLE_MATCH; + } + + //check containing scopes + String [] fullyQualifiedName = ((IASTQualifiedNameElement) node).getFullyQualifiedName(); + if( !matchQualifications( qualifications, fullyQualifiedName ) ){ + return IMPOSSIBLE_MATCH; + } + + return ACCURATE_MATCH; + } + + public char[] indexEntryPrefix() { + return AbstractIndexer.bestMethodPrefix( _limitTo, simpleName, qualifications, _matchMode, _caseSensitive ); + } + + protected boolean matchIndexEntry() { + return true; + } } diff --git a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/NamespaceDeclarationPattern.java b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/NamespaceDeclarationPattern.java index 6d800048807..65dfe1cbef3 100644 --- a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/NamespaceDeclarationPattern.java +++ b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/NamespaceDeclarationPattern.java @@ -15,12 +15,13 @@ package org.eclipse.cdt.internal.core.search.matching; import java.io.IOException; +import org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate; import org.eclipse.cdt.core.parser.ast.IASTNamespaceDefinition; -import org.eclipse.cdt.core.parser.ast.IASTOffsetableElement; import org.eclipse.cdt.core.search.ICSearchScope; import org.eclipse.cdt.internal.core.index.IEntryResult; import org.eclipse.cdt.internal.core.index.impl.IndexInput; import org.eclipse.cdt.internal.core.search.IIndexSearchRequestor; +import org.eclipse.cdt.internal.core.search.indexing.AbstractIndexer; /** * @author aniefer @@ -48,7 +49,7 @@ public class NamespaceDeclarationPattern extends CSearchPattern { /* (non-Javadoc) * @see org.eclipse.cdt.core.search.ICSearchPattern#matchLevel(org.eclipse.cdt.core.parser.ast.IASTOffsetableElement) */ - public int matchLevel(IASTOffsetableElement node) { + public int matchLevel(ISourceElementCallbackDelegate node) { if( !( node instanceof IASTNamespaceDefinition ) ) return IMPOSSIBLE_MATCH; @@ -87,16 +88,19 @@ public class NamespaceDeclarationPattern extends CSearchPattern { * @see org.eclipse.cdt.internal.core.search.matching.CSearchPattern#indexEntryPrefix() */ public char[] indexEntryPrefix() { - // TODO Auto-generated method stub - return null; + return AbstractIndexer.bestNamespacePrefix( + _limitTo, + _name, + _qualifications, + _matchMode, _caseSensitive + ); } - /* (non-Javadoc) * @see org.eclipse.cdt.internal.core.search.matching.CSearchPattern#matchIndexEntry() */ protected boolean matchIndexEntry() { // TODO Auto-generated method stub - return false; + return true; } } diff --git a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/VariableDeclarationPattern.java b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/VariableDeclarationPattern.java index c74602c7aaa..42cf45c4ac5 100644 --- a/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/VariableDeclarationPattern.java +++ b/core/org.eclipse.cdt.core/search/org/eclipse/cdt/internal/core/search/matching/VariableDeclarationPattern.java @@ -15,11 +15,14 @@ package org.eclipse.cdt.internal.core.search.matching; import java.io.IOException; -import org.eclipse.cdt.core.parser.ast.IASTOffsetableElement; +import org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate; +import org.eclipse.cdt.core.parser.ast.IASTOffsetableNamedElement; +import org.eclipse.cdt.core.parser.ast.IASTVariable; import org.eclipse.cdt.core.search.ICSearchScope; import org.eclipse.cdt.internal.core.index.IEntryResult; import org.eclipse.cdt.internal.core.index.impl.IndexInput; import org.eclipse.cdt.internal.core.search.IIndexSearchRequestor; +import org.eclipse.cdt.internal.core.search.indexing.AbstractIndexer; /** * @author aniefer @@ -38,14 +41,25 @@ public class VariableDeclarationPattern extends CSearchPattern { public VariableDeclarationPattern(char[] name, int matchMode, LimitTo limitTo, boolean caseSensitive) { super( matchMode, caseSensitive, limitTo ); + simpleName = name; } /* (non-Javadoc) * @see org.eclipse.cdt.core.search.ICSearchPattern#matchLevel(org.eclipse.cdt.core.parser.ast.IASTOffsetableElement) */ - public int matchLevel(IASTOffsetableElement node) { - // TODO Auto-generated method stub - return 0; + public int matchLevel(ISourceElementCallbackDelegate node) { + if( !(node instanceof IASTVariable) ){ + return IMPOSSIBLE_MATCH; + } + + String nodeName = ((IASTOffsetableNamedElement)node).getName(); + + //check name, if simpleName == null, its treated the same as "*" + if( simpleName != null && !matchesName( simpleName, nodeName.toCharArray() ) ){ + return IMPOSSIBLE_MATCH; + } + + return ACCURATE_MATCH; } /* (non-Javadoc) @@ -68,16 +82,20 @@ public class VariableDeclarationPattern extends CSearchPattern { * @see org.eclipse.cdt.internal.core.search.matching.CSearchPattern#indexEntryPrefix() */ public char[] indexEntryPrefix() { - // TODO Auto-generated method stub - return null; + return AbstractIndexer.bestVariablePrefix( + _limitTo, + simpleName, + _matchMode, _caseSensitive + ); } /* (non-Javadoc) * @see org.eclipse.cdt.internal.core.search.matching.CSearchPattern#matchIndexEntry() */ protected boolean matchIndexEntry() { - // TODO Auto-generated method stub - return false; + return true; } + + protected char [] simpleName; } \ No newline at end of file diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/CSearchResultCollector.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/CSearchResultCollector.java index 05a1aaf494d..a1e8b3df842 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/CSearchResultCollector.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/CSearchResultCollector.java @@ -18,28 +18,21 @@ import java.util.HashMap; import java.util.HashSet; import java.util.Set; -import org.eclipse.cdt.core.parser.ast.ASTClassKind; -import org.eclipse.cdt.core.parser.ast.IASTClassSpecifier; -import org.eclipse.cdt.core.parser.ast.IASTEnumerationSpecifier; -import org.eclipse.cdt.core.parser.ast.IASTNamespaceDefinition; -import org.eclipse.cdt.core.parser.ast.IASTOffsetableNamedElement; -import org.eclipse.cdt.core.parser.ast.IASTQualifiedNameElement; -import org.eclipse.cdt.core.parser.ast.IASTScope; +import org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate; +import org.eclipse.cdt.core.parser.ast.*; import org.eclipse.cdt.core.search.ICSearchResultCollector; import org.eclipse.cdt.core.search.IMatch; import org.eclipse.cdt.internal.ui.CPluginImages; -import org.eclipse.cdt.ui.CUIPlugin; +import org.eclipse.cdt.ui.CElementImageDescriptor; import org.eclipse.core.resources.IMarker; import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.jface.resource.ImageDescriptor; -//import org.eclipse.search.ui.IActionGroupFactory; import org.eclipse.search.ui.ISearchResultView; import org.eclipse.search.ui.SearchUI; -import org.eclipse.swt.graphics.Image; -//import org.eclipse.ui.actions.ActionGroup; +import org.eclipse.swt.graphics.Point; /** * @author aniefer @@ -50,21 +43,28 @@ import org.eclipse.swt.graphics.Image; public class CSearchResultCollector implements ICSearchResultCollector { public static final String IMATCH = "IMatchObject"; + private static final Point SMALL_SIZE= new Point(16, 16); /** * */ public CSearchResultCollector() { super(); - // TODO Auto-generated constructor stub + } + + public CSearchResultCollector( boolean maintain ){ + this(); + _maintainOwnCollection = maintain; } /* (non-Javadoc) * @see org.eclipse.cdt.core.search.ICSearchResultCollector#aboutToStart() */ public void aboutToStart() { - _view = SearchUI.getSearchResultView(); _matchCount = 0; + + _view = SearchUI.getSearchResultView(); + if( _view != null ){ _view.searchStarted( null,//new ActionGroupFactory(), @@ -78,9 +78,14 @@ public class CSearchResultCollector implements ICSearchResultCollector { _operation ); } - if( !getProgressMonitor().isCanceled() ){ + + if( getProgressMonitor() != null && !getProgressMonitor().isCanceled() ){ getProgressMonitor().subTask( SEARCHING ); } + + if( _maintainOwnCollection ){ + _matches = new HashSet(); + } } /* (non-Javadoc) @@ -109,7 +114,12 @@ public class CSearchResultCollector implements ICSearchResultCollector { marker.setAttributes( markerAttributes ); - _view.addMatch( match.name, groupKey, resource, marker ); + if( _view != null ) + _view.addMatch( match.name, groupKey, resource, marker ); + + if( _maintainOwnCollection ){ + _matches.add( enclosingObject ); + } _matchCount++; } @@ -121,21 +131,19 @@ public class CSearchResultCollector implements ICSearchResultCollector { int accuracy) throws CoreException { - if( _matches == null ){ - _matches = new HashSet(); - } - - _matches.add( match ); + if( _maintainOwnCollection ) + _matches.add( match ); } /* (non-Javadoc) * @see org.eclipse.cdt.core.search.ICSearchResultCollector#createMatch(org.eclipse.cdt.core.parser.ast.IASTOffsetableNamedElement) */ - public IMatch createMatch(IASTOffsetableNamedElement node, IASTScope parent ) { - String name = node.getName(); - + public IMatch createMatch(ISourceElementCallbackDelegate node, IASTScope parent ) { + String name = null; String parentName = ""; + IASTOffsetableNamedElement offsetable = null; + if( parent instanceof IASTQualifiedNameElement ){ String [] names = ((IASTQualifiedNameElement)parent).getFullyQualifiedName(); for( int i = 0; i < names.length; i++ ){ @@ -146,6 +154,24 @@ public class CSearchResultCollector implements ICSearchResultCollector { } } + if( node instanceof IASTReference ){ + offsetable = (IASTOffsetableNamedElement) ((IASTReference)node).getReferencedElement(); + name = ((IASTReference)node).getName(); + } else if( node instanceof IASTOffsetableNamedElement ){ + offsetable = (IASTOffsetableNamedElement)node; + name = offsetable.getName(); + } else { + return null; + } + + ImageDescriptor image = getImageDescriptor( offsetable ); + int adornmentFlags = computeAdornmentFlags( offsetable ); + IMatch match = new Match(name, parentName, image );//, node.getNameOffset(), name.length() ); + + return match; + } + + private ImageDescriptor getImageDescriptor( IASTOffsetableElement node ){ ImageDescriptor imageDescriptor = null; if( node instanceof IASTClassSpecifier ){ ASTClassKind kind = ((IASTClassSpecifier)node).getClassKind(); @@ -160,12 +186,55 @@ public class CSearchResultCollector implements ICSearchResultCollector { imageDescriptor = CPluginImages.DESC_OBJS_CONTAINER; } else if ( node instanceof IASTEnumerationSpecifier ){ imageDescriptor = CPluginImages.DESC_OBJS_ENUMERATION; + } else if ( node instanceof IASTField ){ + IASTField field = (IASTField)node; + ASTAccessVisibility visibility = field.getVisiblity(); + if( visibility == ASTAccessVisibility.PUBLIC ){ + imageDescriptor = CPluginImages.DESC_OBJS_PUBLIC_FIELD; + } else if ( visibility == ASTAccessVisibility.PROTECTED) { + imageDescriptor = CPluginImages.DESC_OBJS_PROTECTED_FIELD; + } else if ( visibility == ASTAccessVisibility.PRIVATE ) { + imageDescriptor = CPluginImages.DESC_OBJS_PRIVATE_FIELD; + } + } else if ( node instanceof IASTVariable ){ + imageDescriptor = CPluginImages.DESC_OBJS_FIELD; + } else if ( node instanceof IASTEnumerator ){ + imageDescriptor = CPluginImages.DESC_OBJS_ENUMERATOR; + } else if ( node instanceof IASTMethod ){ + IASTMethod method = (IASTMethod) node; + ASTAccessVisibility visibility = method.getVisiblity(); + if( visibility == ASTAccessVisibility.PUBLIC ){ + imageDescriptor = CPluginImages.DESC_OBJS_PUBLIC_METHOD; + } else if ( visibility == ASTAccessVisibility.PROTECTED) { + imageDescriptor = CPluginImages.DESC_OBJS_PROTECTED_METHOD; + } else if ( visibility == ASTAccessVisibility.PRIVATE ) { + imageDescriptor = CPluginImages.DESC_OBJS_PRIVATE_METHOD; + } + } else if ( node instanceof IASTFunction ){ + imageDescriptor = CPluginImages.DESC_OBJS_FUNCTION; } - Image image = CUIPlugin.getImageDescriptorRegistry().get( imageDescriptor ); - IMatch match = new Match(name, parentName, image, node.getNameOffset(), name.length() ); + if( imageDescriptor != null) { + int adornmentFlags = computeAdornmentFlags( node ); + return new CElementImageDescriptor( imageDescriptor, adornmentFlags, SMALL_SIZE ); + } + return imageDescriptor; + } + + private int computeAdornmentFlags(IASTOffsetableElement element ) { + int flags = 0; + + if( element instanceof IASTVariable ){ + flags |= ((IASTVariable) element).isStatic() ? 0 : CElementImageDescriptor.STATIC; + } else if ( element instanceof IASTMethod ){ + flags |= ((IASTMethod) element).isStatic() ? 0 : CElementImageDescriptor.STATIC; + flags |= ((IASTMethod) element).isConst() ? 0 : CElementImageDescriptor.CONSTANT; + flags |= ((IASTMethod) element).isVolatile() ? 0 : CElementImageDescriptor.VOLATILE; + } else if( element instanceof IASTFunction ){ + flags |= ((IASTFunction) element).isStatic() ? 0 : CElementImageDescriptor.STATIC; + } - return match; + return flags; } /* (non-Javadoc) @@ -210,34 +279,15 @@ public class CSearchResultCollector implements ICSearchResultCollector { return _matches; } - //private class ActionGroupFactory implements IActionGroupFactory { - // public ActionGroup createActionGroup( ISearchResultView part ){ - // return new CSearchViewActionGroup( part ); - // } - //} - - /*public static class Match impl{ - public Match( String path, int start, int end ){ - this.path = path; - this.start = start; - this.end = end; - } - - public String path; - public int start; - public int end; - } - */ private static final String SEARCHING = CSearchMessages.getString("CSearchResultCollector.searching"); //$NON-NLS-1$ private static final String MATCH = CSearchMessages.getString("CSearchResultCollector.match"); //$NON-NLS-1$ private static final String MATCHES = CSearchMessages.getString("CSearchResultCollector.matches"); //$NON-NLS-1$ private static final String DONE = CSearchMessages.getString("CSearchResultCollector.done"); //$NON-NLS-1$ - - private IProgressMonitor _monitor; private CSearchOperation _operation; private ISearchResultView _view; private int _matchCount; private Set _matches; + private boolean _maintainOwnCollection = false; } \ No newline at end of file diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/CSearchResultLabelProvider.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/CSearchResultLabelProvider.java index fcd6043a49e..96290268023 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/CSearchResultLabelProvider.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/CSearchResultLabelProvider.java @@ -15,9 +15,11 @@ package org.eclipse.cdt.internal.ui.search; import org.eclipse.cdt.internal.ui.CElementImageProvider; import org.eclipse.cdt.ui.CElementLabelProvider; +import org.eclipse.cdt.ui.CUIPlugin; import org.eclipse.core.resources.IMarker; import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.CoreException; +import org.eclipse.jface.resource.ImageDescriptor; import org.eclipse.jface.viewers.LabelProvider; import org.eclipse.search.ui.ISearchResultViewEntry; import org.eclipse.swt.graphics.Image; @@ -61,7 +63,11 @@ public class CSearchResultLabelProvider extends LabelProvider { return null; } - return match.image; + ImageDescriptor imageDescriptor = match.imageDesc; + + Image image = CUIPlugin.getImageDescriptorRegistry().get( imageDescriptor ); + + return image; } public String getText( Object element ) { diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/Match.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/Match.java index 6e30bbf5fe0..4427c5692ec 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/Match.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/search/Match.java @@ -14,7 +14,7 @@ package org.eclipse.cdt.internal.ui.search; import org.eclipse.cdt.core.search.IMatch; -import org.eclipse.swt.graphics.Image; +import org.eclipse.jface.resource.ImageDescriptor; /** * @author aniefer @@ -26,14 +26,18 @@ public class Match implements IMatch{ public String name; public String parent; - public Image image; + public ImageDescriptor imageDesc; public int start; public int end; - public Match( String name, String parent, Image image, int start, int end ){ + public Match( String name, String parent, ImageDescriptor image ){ this.name = name; this.parent = parent; - this.image = image; + this.imageDesc = image; + } + + public Match( String name, String parent, ImageDescriptor image, int start, int end ){ + this( name, parent, image ); this.start = start; this.end = end; }