Attachment #38178 for bug #130390




	}
	boolean matchFirstChar = !this.isCaseSensitive || pattern[0] == name[0];
	boolean sameLength = pattern.length == name.length;
	boolean canBePrefix = name.length >= pattern.length;
	if (this.isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
		return POSSIBLE_MATCH;
	}
	switch (this.matchMode) {
		case SearchPattern.R_EXACT_MATCH:
			if (!this.isCamelCase && sameLength && matchFirstChar && CharOperation.equals(pattern, name, this.isCaseSensitive)) {
				return POSSIBLE_FULL_MATCH;
			}
			if (this.isCamelCase) {
				if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {
					return POSSIBLE_PREFIX_MATCH;
				}
				if (matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
					return POSSIBLE_CAMELCASE_MATCH;
				}
			}
			break;
		case SearchPattern.R_PREFIX_MATCH:
			if (sameLength && matchFirstChar && 	CharOperation.equals(pattern, name, this.isCaseSensitive)) {
				return POSSIBLE_FULL_MATCH;
			}
			if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {
				return POSSIBLE_PREFIX_MATCH;
			}
			if (this.isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
				return POSSIBLE_CAMELCASE_MATCH;
			}
			break;
		case SearchPattern.R_PATTERN_MATCH:
			if (!this.isCaseSensitive) {

				return ACCURATE_MATCH;
			}
		}
		if (this.matchMode == SearchPattern.R_EXACT_MATCH) {
			return IMPOSSIBLE_MATCH;
		}
	}
	boolean matchPattern = CharOperation.match(qualifiedPattern, sourceName, this.isCaseSensitive);
	return matchPattern ? ACCURATE_MATCH : IMPOSSIBLE_MATCH;

Lines 52-58 Link Here

(-)buildnotes_jdt-core.html (-1 / +3 lines)
52	What's new in this drop</h2>	52	What's new in this drop</h2>
53		53
54	<h3>Problem Reports Fixed</h3>	54	<h3>Problem Reports Fixed</h3>
55	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=129330">129330</a>	55	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=130390">130390</a>
		56	CamelCase algorithm cleanup and improvement
		57	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=129330">129330</a>
56	strange statement recovery	58	strange statement recovery
57	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=135602">135602</a>	59	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=135602">135602</a>
58	[compiler] Codegen bug for continue statement	60	[compiler] Codegen bug for continue statement




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Luiz-Otávio Zorzella <z0149@zorzella.com> - Improve CamelCase algorithm
 *******************************************************************************/
package org.eclipse.jdt.core.compiler;


		// first char must strictly match (upper/lower)
		return false;
	}

	char patternChar, nameChar;
	int iPattern = patternStart;
	int iName = nameStart;

	// Main loop is on pattern characters
	while (true) {

		iPattern++;
		iName++;

		if (iPattern == patternEnd) {
			// We have exhausted pattern, so it's a match
			return true;
		}

		if (iName == nameEnd){
			// We have exhausted name (and not pattern), so it's not a match 
			return false;
		}

		// For as long as we're exactly matching, bring it on (even if it's a lower case character)
		if ((patternChar = pattern[iPattern]) == name[iName]) {
			continue;
		}

		// If character are not the same then return if patternChar is lowercase
		if (patternChar < ScannerHelper.MAX_OBVIOUS) {
			if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {
				return false;
				break nextPatternChar;
			}
		}
		else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar)) {
			return false;
		}

		// patternChar is uppercase, so let's find the next uppercase in name
		while (true) {
			if (iName == nameEnd){
	            //	We have exhausted name (and not pattern), so it's not a match
				return false;
			}

			nameChar = name[iName];

			if (nameChar < ScannerHelper.MAX_OBVIOUS) {
				if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER | ScannerHelper.C_SPECIAL | ScannerHelper.C_DIGIT)) != 0) {
					// nameChar is lowercase    
					iName++;
				// nameChar is uppercase...
				} else  if (patternChar != nameChar) {
					//.. and it does not match patternChar, so it's not a match
					return false;
				} else {
					//.. and it matched patternChar. Back to the big loop
					break;
				}
			}
			else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {
				// nameChar is lowercase    
				iName++;
			// nameChar is uppercase...
			} else  if (patternChar != nameChar) {
				//.. and it does not match patternChar, so it's not a match
				return false;
			} else {
				//.. and it matched patternChar. Back to the big loop
				break;
			}
				continue nextPatternChar;
			}	
		}
		if (iPattern == patternEnd) return true;
		if (iName == nameEnd) return false;
		continue nextPatternChar;
	}
		
	// check trailing part in case sensitive way
	while (iPattern < patternEnd && iName < nameEnd) {
		if (pattern[iPattern] != name[iName]) {
			return false;
		}
		// At this point, either name has been exhausted, or it is at an uppercase letter.
		// Since pattern is also at an uppercase letter
	}
	return iPattern == patternEnd;
}	

/**




		// first char must strictly match (upper/lower)
		return false;
	}

	char patternChar, nameChar;
	int iPattern = patternStart;
	int iName = nameStart;

	// Main loop is on pattern characters
	while (true) {

		iPattern++;
		iName++;

		if (iPattern == patternEnd) {
			// We have exhausted pattern, so it's a match
			return true;
		}

		if (iName == nameEnd){
			// We have exhausted name (and not pattern), so it's not a match 
			return false;
		}

		// For as long as we're exactly matching, bring it on (even if it's a lower case character)
		if ((patternChar = pattern.charAt(iPattern)) == name.charAt(iName)) {
			continue;
		}

		// If character are not the same then return if patternChar is lowercase
		if (patternChar < ScannerHelper.MAX_OBVIOUS) {
			if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {
				return false;
				break nextPatternChar;
			}
		}
		else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar)) {
			return false;
		}

		// patternChar is uppercase, so let's find the next uppercase in name
		while (true) {
			if (iName == nameEnd){
	            //	We have exhausted name (and not pattern), so it's not a match
				return false;
			}

			nameChar = name.charAt(iName);

			if (nameChar < ScannerHelper.MAX_OBVIOUS) {
				if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER | ScannerHelper.C_SPECIAL | ScannerHelper.C_DIGIT)) != 0) {
					// nameChar is lowercase    
					iName++;
				// nameChar is uppercase...
				} else  if (patternChar != nameChar) {
					//.. and it does not match patternChar, so it's not a match
					return false;
				} else {
					//.. and it matched patternChar. Back to the big loop
					break;
				}
			}
			else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {
				// nameChar is lowercase    
				iName++;
			// nameChar is uppercase...
			} else  if (patternChar != nameChar) {
				//.. and it does not match patternChar, so it's not a match
				return false;
			} else {
				//.. and it matched patternChar. Back to the big loop
				break;
			}
				continue nextPatternChar;
			}	
		}
		if (iPattern == patternEnd) return true;
		if (iName == nameEnd) return false;
		continue nextPatternChar;
	}
		
	// check trailing part in case sensitive way
	while (iPattern < patternEnd && iName < nameEnd) {
		if (pattern.charAt(iPattern) != name.charAt(iName)) {
			return false;
		}
		// At this point, either name has been exhausted, or it is at an uppercase letter.
		// Since pattern is also at an uppercase letter
	}
	return iPattern == patternEnd;
}	

/**

		boolean isCaseSensitive = (this.matchRule & R_CASE_SENSITIVE) != 0;
		boolean isCamelCase = (this.matchRule & R_CAMELCASE_MATCH) != 0;
		int matchMode = this.matchRule & MODE_MASK;
		boolean sameLength = pattern.length == name.length;
		boolean canBePrefix = name.length >= pattern.length;
		boolean matchFirstChar = !isCaseSensitive || pattern.length == 0 || (name.length > 0 &&  pattern[0] == name[0]);
		if (isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
			return true;

		switch (matchMode) {
			case R_EXACT_MATCH :
			case R_FULL_MATCH :
				if (!isCamelCase && sameLength && matchFirstChar) {
					return CharOperation.equals(pattern, name, isCaseSensitive);
				}
				break;

			case R_PREFIX_MATCH :
				if (canBePrefix && matchFirstChar) {
					return CharOperation.prefixEquals(pattern, name, isCaseSensitive);
				}
				break;

			case R_PATTERN_MATCH :
				if (!isCaseSensitive)

	if ((matchRule & R_CAMELCASE_MATCH) != 0) {
		// Verify sting pattern validity
		int length = stringPattern.length();
		boolean validCamelCase = true;
		for (int i=0; i<length && validCamelCase; i++) {
			char ch = stringPattern.charAt(i++);
			validCamelCase = ScannerHelper.isJavaIdentifierStart(ch);
			if (ScannerHelper.isJavaIdentifierStart(ch)) {
				ch = stringPattern.charAt(idx++);
				if (ScannerHelper.isUpperCase(ch)) {
					while (idx<length && ScannerHelper.isUpperCase(stringPattern.charAt(idx))) {
						idx++;
					}
					while (idx<length && (!ScannerHelper.isUpperCase(ch=stringPattern.charAt(idx)) && ScannerHelper.isJavaIdentifierPart(ch))) {
						idx++;
					}
					validCamelCase = idx == length;
				}
			}
		}
		// Verify bits compatibility
		if (validCamelCase) {

Lines 49-55 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java (-1 / +104 lines)
49	// org.eclipse.jdt.internal.codeassist.SelectionEngine.DEBUG = true;	49	// org.eclipse.jdt.internal.codeassist.SelectionEngine.DEBUG = true;
50	// TESTS_PREFIX = "testBug110060";	50	// TESTS_PREFIX = "testBug110060";
51	// TESTS_NAMES = new String[] { "testBug126330" };	51	// TESTS_NAMES = new String[] { "testBug126330" };
52	// TESTS_NUMBERS = new int[] { 89686 };	52	// TESTS_NUMBERS = new int[] { 110060, 130390 };
53	// TESTS_RANGE = new int[] { 83304, -1 };	53	// TESTS_RANGE = new int[] { 83304, -1 };
54	}	54	}
55		55
Lines 4400-4405 Link Here
4400	}	4400	}
4401		4401
4402	/**	4402	/**
		4403	* To get these tests search matches in a workspace, do NOT forget to modify files
		4404	* to set them as working copies.
		4405	*
4403	* @test Bug 110060: [plan][search] Add support for Camel Case search pattern	4406	* @test Bug 110060: [plan][search] Add support for Camel Case search pattern
4404	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=110060"	4407	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=110060"
4405	*/	4408	*/
Lines 5918-5921 Link Here
5918	);	5921	);
5919	}	5922	}
5920		5923
		5924
		5925	/**
		5926	* To get these tests search matches in a workspace, do NOT forget to modify files
		5927	* to set them as working copies.
		5928	*
		5929	* @test Bug 130390: CamelCase algorithm cleanup and improvement
		5930	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=130390"
		5931	*/
		5932	public void testBug130390() throws CoreException {
		5933	workingCopies = new ICompilationUnit[4];
		5934	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b130390/TZ.java",
		5935	"package b130390;\n" +
		5936	"public class TZ {\n" +
		5937	"}\n"
		5938	);
		5939	workingCopies[1] = getWorkingCopy("/JavaSearchBugs/src/b130390/TimeZone.java",
		5940	"package b130390;\n" +
		5941	"public class TimeZone{\n" +
		5942	"}\n"
		5943	);
		5944	workingCopies[2] = getWorkingCopy("/JavaSearchBugs/src/b130390/Npe.java",
		5945	"package b130390;\n" +
		5946	"public class Npe {\n" +
		5947	"}\n"
		5948	);
		5949	workingCopies[3] = getWorkingCopy("/JavaSearchBugs/src/b130390/NullPointerException.java",
		5950	"package b130390;\n" +
		5951	"public class NullPointerException {\n" +
		5952	"}\n"
		5953	);
		5954	search("NuPoEx", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
		5955	this.discard = false;
		5956	assertSearchResults(
		5957	"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
		5958	);
		5959	}
		5960	public void testBug130390b() throws CoreException {
		5961	assertNotNull("There should be working copies!", workingCopies);
		5962	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
		5963	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
		5964	this.discard = false;
		5965	assertSearchResults(
		5966	"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
		5967	);
		5968	}
		5969	public void testBug130390c() throws CoreException {
		5970	assertNotNull("There should be working copies!", workingCopies);
		5971	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
		5972	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_CASE_SENSITIVE);
		5973	this.discard = false;
		5974	assertSearchResults(
		5975	"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
		5976	);
		5977	}
		5978	public void testBug130390d() throws CoreException {
		5979	assertNotNull("There should be working copies!", workingCopies);
		5980	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
		5981	search("Npe", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
		5982	this.discard = false;
		5983	assertSearchResults(
		5984	"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
		5985	);
		5986	}
		5987	public void testBug130390e() throws CoreException {
5988	assertNotNull("There should be working copies!", workingCopies);
5989	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
5990	search("Npe", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_CASE_SENSITIVE);
5991	this.discard = false;
5992	assertSearchResults(
5993	"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
5994	);
5995	}
5996	public void testBug130390f() throws CoreException {
5997	assertNotNull("There should be working copies!", workingCopies);
5998	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
5999	search("NullPE", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
6000	this.discard = false;
6001	assertSearchResults(
6002	"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
6003	);
6004	}
6005	public void testBug130390g() throws CoreException {
6006	assertNotNull("There should be working copies!", workingCopies);
6007	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
6008	search("TZ", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_CASE_SENSITIVE);
6009	this.discard = false;
6010	assertSearchResults(
6011	"src/b130390/TZ.java b130390.TZ [TZ] EXACT_MATCH\n" +
6012	"src/b130390/TimeZone.java b130390.TimeZone [TimeZone] EXACT_MATCH"
6013	);
6014	}
6015	public void testBug130390h() throws CoreException {
6016	assertNotNull("There should be working copies!", workingCopies);
6017	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
6018	search("TiZo", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_CASE_SENSITIVE);
6019	this.discard = false;
6020	assertSearchResults(
6021	"src/b130390/TimeZone.java b130390.TimeZone [TimeZone] EXACT_MATCH"
6022	);
6023	}
5921	}	6024	}

Lines 19-31 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/UtilTest.java (-59 / +120 lines)
19	import junit.framework.Test;	19	import junit.framework.Test;
20		20
21	public class UtilTest extends AbstractRegressionTest {	21	public class UtilTest extends AbstractRegressionTest {
22		22
		23	StringBuffer camelCaseErrors;
		24
23	public UtilTest(String name) {	25	public UtilTest(String name) {
24	super(name);	26	super(name);
25	}	27	}
		28	static {
		29	// TESTS_RANGE = new int[] { 62, -1 };
		30	}
26	public static Test suite() {	31	public static Test suite() {
27	return buildAllCompliancesTestSuite(testClass());	32	return buildAllCompliancesTestSuite(testClass());
28	}	33	}
		34	/**
		35	* Assert that a pattern and a name matches or not.
		36	* If result is invalid then store warning in buffer and display it.
		37	*/
		38	void assertCamelCase(String pattern, String name, boolean match) {
		39	boolean camelCase = CharOperation.camelCaseMatch(pattern==null?null:pattern.toCharArray(), name==null?null:name.toCharArray());
		40	if (match != camelCase) {
		41	StringBuffer line = new StringBuffer("'");
		42	line.append(name);
		43	line.append("' SHOULD");
		44	if (!match) line.append(" NOT");
		45	line.append(" match pattern '");
		46	line.append(pattern);
		47	line.append("'");
		48	if (this.camelCaseErrors.length() == 0) {
		49	System.out.println("Invalid results in test "+getName()+":");
		50	}
		51	System.out.println(" - "+line);
		52	this.camelCaseErrors.append('\n');
		53	this.camelCaseErrors.append(line);
		54	}
		55	}
		56	/* (non-Javadoc)
		57	* @see org.eclipse.jdt.core.tests.compiler.regression.AbstractRegressionTest#setUp()
		58	*/
		59	protected void setUp() throws Exception {
		60	super.setUp();
		61	this.camelCaseErrors = new StringBuffer();
		62	}
		63
29	public boolean checkPathMatch(char[] pattern, char[] path, boolean isCaseSensitive) {	64	public boolean checkPathMatch(char[] pattern, char[] path, boolean isCaseSensitive) {
30		65
31	CharOperation.replace(pattern, '/', File.separatorChar);	66	CharOperation.replace(pattern, '/', File.separatorChar);
Lines 430-499 Link Here
430	checkPathMatch("/P/src/**/CVS/".toCharArray(), "/P/src/CVS".toCharArray(), true));	465	checkPathMatch("/P/src/**/CVS/".toCharArray(), "/P/src/CVS".toCharArray(), true));
431	}	466	}
432	public void test62() {	467	public void test62() {
433	assertTrue("Camel pattern matching failure-1",	468	assertCamelCase("NPE", "NullPointerException", true/* should match */);
434	CharOperation.camelCaseMatch("NPE".toCharArray(), "NullPointerException".toCharArray()));	469	assertCamelCase("NPExc", "NullPointerException", true/* should match */);
435	assertTrue("Camel pattern matching failure-2",	470	assertCamelCase("NPoE", "NullPointerException", true/* should match */);
436	CharOperation.camelCaseMatch("NPExc".toCharArray(), "NullPointerException".toCharArray()));	471	assertCamelCase("NuPExc", "NullPointerException", true/* should match */);
437	assertTrue("Camel pattern matching failure-3",	472	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
438	!CharOperation.camelCaseMatch("NPoE".toCharArray(), "NullPointerException".toCharArray()));
439	assertTrue("Camel pattern matching failure-4",
440	!CharOperation.camelCaseMatch("NuPExc".toCharArray(), "NullPointerException".toCharArray()));
441	}	473	}
442	public void test63() {	474	public void test63() {
443	assertTrue("Camel pattern matching failure-1",	475	assertCamelCase("NPEX", "NullPointerException", false/* should not match */);
444	!CharOperation.camelCaseMatch("NPEX".toCharArray(), "NullPointerException".toCharArray()));	476	assertCamelCase("NPex", "NullPointerException", false/* should not match */);
445	assertTrue("Camel pattern matching failure-2",	477	assertCamelCase("npe", "NullPointerException", false/* should not match */);
446	!CharOperation.camelCaseMatch("NPex".toCharArray(), "NullPointerException".toCharArray()));	478	assertCamelCase("npe", "NPException", false/* should not match */);
447	assertTrue("Camel pattern matching failure-3",	479	assertCamelCase("NPointerE", "NullPointerException", true/* should match */);
448	!CharOperation.camelCaseMatch("npe".toCharArray(), "NullPointerException".toCharArray()));	480	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
449	assertTrue("Camel pattern matching failure-4",
450	!CharOperation.camelCaseMatch("npe".toCharArray(), "NPException".toCharArray()));
451	assertTrue("Camel pattern matching failure-5",
452	CharOperation.camelCaseMatch("NPointerE".toCharArray(), "NullPointerException".toCharArray()));
453	}	481	}
454	public void test64() {	482	public void test64() {
455	assertTrue("Camel pattern matching failure-1",	483	assertCamelCase("IAE", "IgnoreAllErrorHandler", true/* should match */);
456	CharOperation.camelCaseMatch("IAE".toCharArray(), "IgnoreAllErrorHandler".toCharArray()));	484	assertCamelCase("IAE", "IAnchorElement", true/* should match */);
457	assertTrue("Camel pattern matching failure-2",	485	assertCamelCase("IAnchorEleme", "IAnchorElement", true/* should match */);
458	CharOperation.camelCaseMatch("IAE".toCharArray(), "IAnchorElement".toCharArray()));	486	assertCamelCase("", "IAnchorElement", false/* should not match */);
459	assertTrue("Camel pattern matching failure-3",	487	assertCamelCase(null, "IAnchorElement", true/* should match */);
460	CharOperation.camelCaseMatch("IAnchorEleme".toCharArray(), "IAnchorElement".toCharArray()));	488	assertCamelCase("", "", true/* should match */);
461	assertTrue("Camel pattern matching failure-4",	489	assertCamelCase("IAnchor", null, false/* should not match */);
462	!CharOperation.camelCaseMatch("".toCharArray(), "IAnchorElement".toCharArray()));	490	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
463	assertTrue("Camel pattern matching failure-5",
464	CharOperation.camelCaseMatch(null, "IAnchorElement".toCharArray()));
465	assertTrue("Camel pattern matching failure-6",
466	CharOperation.camelCaseMatch("".toCharArray(), "".toCharArray()));
467	assertTrue("Camel pattern matching failure-7",
468	!CharOperation.camelCaseMatch("IAnchor".toCharArray(), null));
469	}	491	}
470	public void test65() {	492	public void test65() {
471	assertTrue("Camel pattern matching failure-1",	493	assertCamelCase("iSCDCo", "invokeStringConcatenationDefaultConstructor", true/* should match */);
472	CharOperation.camelCaseMatch("iSCDCo".toCharArray(), "invokeStringConcatenationDefaultConstructor".toCharArray()));	494	assertCamelCase("inVOke", "invokeStringConcatenationDefaultConstructor", false/* should not match */);
473	assertTrue("Camel pattern matching failure-2",	495	assertCamelCase("i", "invokeStringConcatenationDefaultConstructor", true/* should match */);
474	!CharOperation.camelCaseMatch("inVOke".toCharArray(), "invokeStringConcatenationDefaultConstructor".toCharArray()));	496	assertCamelCase("I", "invokeStringConcatenationDefaultConstructor", false/* should not match */);
475	assertTrue("Camel pattern matching failure-3",	497	assertCamelCase("iStringCD", "invokeStringConcatenationDefaultConstructor", true/* should match */);
476	CharOperation.camelCaseMatch("i".toCharArray(), "invokeStringConcatenationDefaultConstructor".toCharArray()));	498	assertCamelCase("NPE", "NullPointerException/java.lang", true/* should match */);
477	assertTrue("Camel pattern matching failure-4",	499	assertCamelCase("NPE", "NullPointer/lang.Exception", false/* should not match */);
478	!CharOperation.camelCaseMatch("I".toCharArray(), "invokeStringConcatenationDefaultConstructor".toCharArray()));	500	assertCamelCase("NPE", "Null_Pointer$Exception", true/* should match */);
479	assertTrue("Camel pattern matching failure-5",	501	assertCamelCase("NPE", "Null1Pointer2Exception", true/* should match */);
480	!CharOperation.camelCaseMatch("iStringCD".toCharArray(), "invokeStringConcatenationDefaultConstructor".toCharArray()));	502	assertCamelCase("NPE", "Null.Pointer.Exception", false/* should not match */);
481	assertTrue("Camel pattern matching failure-6",	503	assertCamelCase("NPE", "aNullPointerException", false/* should not match */);
482	CharOperation.camelCaseMatch("NPE".toCharArray(), "NullPointerException/java.lang".toCharArray()));	504	assertCamelCase("nullP", "nullPointerException", true/* should match */);
483	assertTrue("Camel pattern matching failure-7",	505	assertCamelCase("nP", "nullPointerException", true/* should match */);
484	!CharOperation.camelCaseMatch("NPE".toCharArray(), "NullPointer/lang.Exception".toCharArray()));	506	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
485	assertTrue("Camel pattern matching failure-8",	507	}
486	CharOperation.camelCaseMatch("NPE".toCharArray(), "Null_Pointer$Exception".toCharArray()));	508
487	assertTrue("Camel pattern matching failure-9",	509	/**
488	CharOperation.camelCaseMatch("NPE".toCharArray(), "Null1Pointer2Exception".toCharArray()));	510	* Bug 130390: CamelCase algorithm cleanup and improvement
489	assertTrue("Camel pattern matching failure-10",	511	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=130390"
490	!CharOperation.camelCaseMatch("NPE".toCharArray(), "Null.Pointer.Exception".toCharArray()));	512	*
491	assertTrue("Camel pattern matching failure-11",	513	*/
492	!CharOperation.camelCaseMatch("NPE".toCharArray(), "aNullPointerException".toCharArray()));	514	public void test66() {
493	assertTrue("Camel pattern matching failure-12",	515	String[][] MATCHES = {
494	CharOperation.camelCaseMatch("nullP".toCharArray(), "nullPointerException".toCharArray()));	516	{"TZ","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
495	assertTrue("Camel pattern matching failure-13",	517	{"TiZ","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
496	CharOperation.camelCaseMatch("nP".toCharArray(), "nullPointerException".toCharArray()));	518	{"TiZon","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		519	{"TZon","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		520	{"TZone","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		521	{"TimeZone","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		522	{"TimeZ","TimeZ"}, //$NON-NLS-1$//$NON-NLS-2$
		523	{"TZ","TimeZ"}, //$NON-NLS-1$//$NON-NLS-2$
		524	{"T","TimeZ"}, //$NON-NLS-1$//$NON-NLS-2$
		525	{"T","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		526	{"TZ","TZ"}, //$NON-NLS-1$//$NON-NLS-2$
		527	{"aT","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		528	{"aTi","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		529	{"aTiZ","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		530	{"aTZ","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		531	{"aT","artTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		532	{"aTi","artTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		533	{"aTiZ","artTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		534	{"aTZ","artTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		535	};
		536
		537	for (int i = 0; i<MATCHES.length ; i++) {
		538	String[] match = MATCHES[i];
		539	assertCamelCase(match[0], match[1], true/should match/);
		540	}
		541
		542	String[][] MIS_MATCHES = {
		543	{"TZ","Timezone"}, //$NON-NLS-1$//$NON-NLS-2$
		544	{"aTZ","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		545	{"aTZ","TZ"}, //$NON-NLS-1$//$NON-NLS-2$
		546	{"arT","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		547	{"arTi","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		548	{"arTiZ","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		549	{"arTZ","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		550	{"aT","atimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		551	};
		552
		553	for (int i = 0; i<MIS_MATCHES.length ; i++) {
		554	String[] match = MIS_MATCHES[i];
		555	assertCamelCase(match[0], match[1], false/should not match/);
		556	}
		557	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
497	}	558	}
498	public static Class testClass() {	559	public static Class testClass() {
499	return UtilTest.class;	560	return UtilTest.class;

Return to bug 130390

Lines 270-300 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java (-16 / +8 lines)
270	}	270	}
271	boolean matchFirstChar = !this.isCaseSensitive \|\| pattern[0] == name[0];	271	boolean matchFirstChar = !this.isCaseSensitive \|\| pattern[0] == name[0];
272	boolean sameLength = pattern.length == name.length;	272	boolean sameLength = pattern.length == name.length;
273	boolean canBePrefix = name.length > pattern.length;	273	boolean canBePrefix = name.length >= pattern.length;
		274	if (this.isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
		275	return POSSIBLE_MATCH;
		276	}
274	switch (this.matchMode) {	277	switch (this.matchMode) {
275	case SearchPattern.R_EXACT_MATCH:	278	case SearchPattern.R_EXACT_MATCH:
276	if (sameLength && matchFirstChar && CharOperation.equals(pattern, name, this.isCaseSensitive)) {	279	if (!this.isCamelCase && sameLength && matchFirstChar && CharOperation.equals(pattern, name, this.isCaseSensitive)) {
277	return POSSIBLE_FULL_MATCH;	280	return POSSIBLE_FULL_MATCH;
278	}	281	}
279	if (this.isCamelCase) {
280	if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {
281	return POSSIBLE_PREFIX_MATCH;
282	}
283	if (matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
284	return POSSIBLE_CAMELCASE_MATCH;
285	}
286	}
287	break;	282	break;
288	case SearchPattern.R_PREFIX_MATCH:	283	case SearchPattern.R_PREFIX_MATCH:
289	if (sameLength && matchFirstChar && CharOperation.equals(pattern, name, this.isCaseSensitive)) {
290	return POSSIBLE_FULL_MATCH;
291	}
292	if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {	284	if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {
293	return POSSIBLE_PREFIX_MATCH;	285	return POSSIBLE_PREFIX_MATCH;
294	}	286	}
295	if (this.isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
296	return POSSIBLE_CAMELCASE_MATCH;
297	}
298	break;	287	break;
299	case SearchPattern.R_PATTERN_MATCH:	288	case SearchPattern.R_PATTERN_MATCH:
300	if (!this.isCaseSensitive) {	289	if (!this.isCaseSensitive) {
Lines 702-707 Link Here
702	return ACCURATE_MATCH;	691	return ACCURATE_MATCH;
703	}	692	}
704	}	693	}
		694	if (this.matchMode == SearchPattern.R_EXACT_MATCH) {
		695	return IMPOSSIBLE_MATCH;
		696	}
705	}	697	}
706	boolean matchPattern = CharOperation.match(qualifiedPattern, sourceName, this.isCaseSensitive);	698	boolean matchPattern = CharOperation.match(qualifiedPattern, sourceName, this.isCaseSensitive);
707	return matchPattern ? ACCURATE_MATCH : IMPOSSIBLE_MATCH;	699	return matchPattern ? ACCURATE_MATCH : IMPOSSIBLE_MATCH;

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/CharOperation.java (-44 / +65 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Luiz-Otávio Zorzella <z0149@zorzella.com> - Improve CamelCase algorithm
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.core.compiler;	12	package org.eclipse.jdt.core.compiler;
12		13
Lines 283-341 Link Here
283	// first char must strictly match (upper/lower)	284	// first char must strictly match (upper/lower)
284	return false;	285	return false;
285	}	286	}
		287
286	char patternChar, nameChar;	288	char patternChar, nameChar;
287	int iPattern = patternStart+1;	289	int iPattern = patternStart;
288	int iName = nameStart+1;	290	int iName = nameStart;
289	nextPatternChar: while (iPattern < patternEnd) {	291
290	// check patternChar, keep camelCasing only if uppercase	292	// Main loop is on pattern characters
291	if ((patternChar = pattern[iPattern]) < ScannerHelper.MAX_OBVIOUS) {	293	while (true) {
		294
		295	iPattern++;
		296	iName++;
		297
		298	if (iPattern == patternEnd) {
		299	// We have exhausted pattern, so it's a match
		300	return true;
		301	}
		302
		303	if (iName == nameEnd){
		304	// We have exhausted name (and not pattern), so it's not a match
		305	return false;
		306	}
		307
		308	// For as long as we're exactly matching, bring it on (even if it's a lower case character)
		309	if ((patternChar = pattern[iPattern]) == name[iName]) {
		310	continue;
		311	}
		312
		313	// If character are not the same then return if patternChar is lowercase
		314	if (patternChar < ScannerHelper.MAX_OBVIOUS) {
292	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {	315	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {
293	// end of camelCase part of pattern	316	return false;
294	break nextPatternChar;
295	}	317	}
296	// still uppercase	318	}
297	} else if (ScannerHelper.isJavaIdentifierPart(patternChar)	319	else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar)) {
298	&& !ScannerHelper.isUpperCase(patternChar)) {	320	return false;
299	// end of camelCase part of pattern	321	}
300	break nextPatternChar;	322
301	}	323	// patternChar is uppercase, so let's find the next uppercase in name
302	nextNameChar: while (iName < nameEnd) {	324	while (true) {
303	if ((nameChar = name[iName]) != patternChar) {	325	if (iName == nameEnd){
304	if (nameChar < ScannerHelper.MAX_OBVIOUS) {	326	// We have exhausted name (and not pattern), so it's not a match
305	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER \| ScannerHelper.C_SPECIAL \| ScannerHelper.C_DIGIT)) != 0) {	327	return false;
306	// lowercase/digit char is ignored	328	}
307	iName++;	329
308	continue nextNameChar;	330	nameChar = name[iName];
309	}	331
310	} else if (ScannerHelper.isJavaIdentifierPart(nameChar)	332	if (nameChar < ScannerHelper.MAX_OBVIOUS) {
311	&& !ScannerHelper.isUpperCase(nameChar)) {	333	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER \| ScannerHelper.C_SPECIAL \| ScannerHelper.C_DIGIT)) != 0) {
312	// lowercase name char is ignored	334	// nameChar is lowercase
313	iName++;	335	iName++;
314	continue nextNameChar;	336	// nameChar is uppercase...
		337	} else if (patternChar != nameChar) {
		338	//.. and it does not match patternChar, so it's not a match
		339	return false;
		340	} else {
		341	//.. and it matched patternChar. Back to the big loop
		342	break;
315	}	343	}
316	// mismatch, either uppercase in name or non case char ('/' etc)--> reject	344	}
		345	else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {
		346	// nameChar is lowercase
		347	iName++;
		348	// nameChar is uppercase...
		349	} else if (patternChar != nameChar) {
		350	//.. and it does not match patternChar, so it's not a match
317	return false;	351	return false;
318	} else {	352	} else {
319	// pattern char == name char (uppercase)	353	//.. and it matched patternChar. Back to the big loop
320	iName++;	354	break;
321	iPattern++;	355	}
322	continue nextPatternChar;
323	}
324	}
325	if (iPattern == patternEnd) return true;
326	if (iName == nameEnd) return false;
327	continue nextPatternChar;
328	}
329
330	// check trailing part in case sensitive way
331	while (iPattern < patternEnd && iName < nameEnd) {
332	if (pattern[iPattern] != name[iName]) {
333	return false;
334	}	356	}
335	iPattern++;	357	// At this point, either name has been exhausted, or it is at an uppercase letter.
336	iName++;	358	// Since pattern is also at an uppercase letter
337	}	359	}
338	return iPattern == patternEnd;
339	}	360	}
340		361
341	/**	362	/**

Lines 307-365 Link Here

(-)search/org/eclipse/jdt/core/search/SearchPattern.java (-63 / +78 lines)
307	// first char must strictly match (upper/lower)	307	// first char must strictly match (upper/lower)
308	return false;	308	return false;
309	}	309	}
		310
310	char patternChar, nameChar;	311	char patternChar, nameChar;
311	int iPattern = patternStart+1;	312	int iPattern = patternStart;
312	int iName = nameStart+1;	313	int iName = nameStart;
313	nextPatternChar: while (iPattern < patternEnd) {	314
314	// check patternChar, keep camelCasing only if uppercase	315	// Main loop is on pattern characters
315	if ((patternChar = pattern.charAt(iPattern)) < ScannerHelper.MAX_OBVIOUS) {	316	while (true) {
		317
		318	iPattern++;
		319	iName++;
		320
		321	if (iPattern == patternEnd) {
		322	// We have exhausted pattern, so it's a match
		323	return true;
		324	}
		325
		326	if (iName == nameEnd){
		327	// We have exhausted name (and not pattern), so it's not a match
		328	return false;
		329	}
		330
		331	// For as long as we're exactly matching, bring it on (even if it's a lower case character)
		332	if ((patternChar = pattern.charAt(iPattern)) == name.charAt(iName)) {
		333	continue;
		334	}
		335
		336	// If character are not the same then return if patternChar is lowercase
		337	if (patternChar < ScannerHelper.MAX_OBVIOUS) {
316	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {	338	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {
317	// end of camelCase part of pattern	339	return false;
318	break nextPatternChar;
319	}	340	}
320	// still uppercase	341	}
321	} else if (ScannerHelper.isJavaIdentifierPart(patternChar)	342	else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar)) {
322	&& !ScannerHelper.isUpperCase(patternChar)) {	343	return false;
323	// end of camelCase part of pattern	344	}
324	break nextPatternChar;	345
325	}	346	// patternChar is uppercase, so let's find the next uppercase in name
326	nextNameChar: while (iName < nameEnd) {	347	while (true) {
327	if ((nameChar = name.charAt(iName)) != patternChar) {	348	if (iName == nameEnd){
328	if (nameChar < ScannerHelper.MAX_OBVIOUS) {	349	// We have exhausted name (and not pattern), so it's not a match
329	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER\|ScannerHelper.C_SPECIAL \|ScannerHelper.C_DIGIT)) != 0) {	350	return false;
330	// lowercase/digit char is ignored	351	}
331	iName++;	352
332	continue nextNameChar;	353	nameChar = name.charAt(iName);
333	}	354
334	} else if (ScannerHelper.isJavaIdentifierPart(nameChar)	355	if (nameChar < ScannerHelper.MAX_OBVIOUS) {
335	&& !ScannerHelper.isUpperCase(nameChar)) {	356	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER \| ScannerHelper.C_SPECIAL \| ScannerHelper.C_DIGIT)) != 0) {
336	// lowercase name char is ignored	357	// nameChar is lowercase
337	iName++;	358	iName++;
338	continue nextNameChar;	359	// nameChar is uppercase...
		360	} else if (patternChar != nameChar) {
		361	//.. and it does not match patternChar, so it's not a match
		362	return false;
		363	} else {
		364	//.. and it matched patternChar. Back to the big loop
		365	break;
339	}	366	}
340	// mismatch, either uppercase in name or non case char ('/' etc)--> reject	367	}
		368	else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {
		369	// nameChar is lowercase
		370	iName++;
		371	// nameChar is uppercase...
		372	} else if (patternChar != nameChar) {
		373	//.. and it does not match patternChar, so it's not a match
341	return false;	374	return false;
342	} else {	375	} else {
343	// pattern char == name char (uppercase)	376	//.. and it matched patternChar. Back to the big loop
344	iName++;	377	break;
345	iPattern++;	378	}
346	continue nextPatternChar;
347	}
348	}
349	if (iPattern == patternEnd) return true;
350	if (iName == nameEnd) return false;
351	continue nextPatternChar;
352	}
353
354	// check trailing part in case sensitive way
355	while (iPattern < patternEnd && iName < nameEnd) {
356	if (pattern.charAt(iPattern) != name.charAt(iName)) {
357	return false;
358	}	379	}
359	iPattern++;	380	// At this point, either name has been exhausted, or it is at an uppercase letter.
360	iName++;	381	// Since pattern is also at an uppercase letter
361	}	382	}
362	return iPattern == patternEnd;
363	}	383	}
364		384
365	/**	385	/**
Lines 1715-1720 Link Here
1715	boolean isCaseSensitive = (this.matchRule & R_CASE_SENSITIVE) != 0;	1735	boolean isCaseSensitive = (this.matchRule & R_CASE_SENSITIVE) != 0;
1716	boolean isCamelCase = (this.matchRule & R_CAMELCASE_MATCH) != 0;	1736	boolean isCamelCase = (this.matchRule & R_CAMELCASE_MATCH) != 0;
1717	int matchMode = this.matchRule & MODE_MASK;	1737	int matchMode = this.matchRule & MODE_MASK;
		1738	boolean sameLength = pattern.length == name.length;
		1739	boolean canBePrefix = name.length >= pattern.length;
1718	boolean matchFirstChar = !isCaseSensitive \|\| pattern.length == 0 \|\| (name.length > 0 && pattern[0] == name[0]);	1740	boolean matchFirstChar = !isCaseSensitive \|\| pattern.length == 0 \|\| (name.length > 0 && pattern[0] == name[0]);
1719	if (isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {	1741	if (isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
1720	return true;	1742	return true;
Lines 1722-1732 Link Here
1722	switch (matchMode) {	1744	switch (matchMode) {
1723	case R_EXACT_MATCH :	1745	case R_EXACT_MATCH :
1724	case R_FULL_MATCH :	1746	case R_FULL_MATCH :
1725	if (isCamelCase) return false;	1747	if (!isCamelCase && sameLength && matchFirstChar) {
1726	return matchFirstChar && CharOperation.equals(pattern, name, isCaseSensitive);	1748	return CharOperation.equals(pattern, name, isCaseSensitive);
		1749	}
		1750	break;
1727		1751
1728	case R_PREFIX_MATCH :	1752	case R_PREFIX_MATCH :
1729	return matchFirstChar && CharOperation.prefixEquals(pattern, name, isCaseSensitive);	1753	if (canBePrefix && matchFirstChar) {
		1754	return CharOperation.prefixEquals(pattern, name, isCaseSensitive);
		1755	}
		1756	break;
1730		1757
1731	case R_PATTERN_MATCH :	1758	case R_PATTERN_MATCH :
1732	if (!isCaseSensitive)	1759	if (!isCaseSensitive)
Lines 1805-1826 Link Here
1805	if ((matchRule & R_CAMELCASE_MATCH) != 0) {	1832	if ((matchRule & R_CAMELCASE_MATCH) != 0) {
1806	// Verify sting pattern validity	1833	// Verify sting pattern validity
1807	int length = stringPattern.length();	1834	int length = stringPattern.length();
1808	boolean validCamelCase = false;	1835	boolean validCamelCase = true;
1809	if (length > 1) {	1836	for (int i=0; i<length && validCamelCase; i++) {
1810	int idx = 0;	1837	char ch = stringPattern.charAt(i++);
1811	char ch = stringPattern.charAt(idx++);	1838	validCamelCase = ScannerHelper.isJavaIdentifierStart(ch);
1812	if (ScannerHelper.isJavaIdentifierStart(ch)) {
1813	ch = stringPattern.charAt(idx++);
1814	if (ScannerHelper.isUpperCase(ch)) {
1815	while (idx<length && ScannerHelper.isUpperCase(stringPattern.charAt(idx))) {
1816	idx++;
1817	}
1818	while (idx<length && (!ScannerHelper.isUpperCase(ch=stringPattern.charAt(idx)) && ScannerHelper.isJavaIdentifierPart(ch))) {
1819	idx++;
1820	}
1821	validCamelCase = idx == length;
1822	}
1823	}
1824	}	1839	}
1825	// Verify bits compatibility	1840	// Verify bits compatibility
1826	if (validCamelCase) {	1841	if (validCamelCase) {