Attachment #38134 for bug #130390




		// 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 
	}
	return iPattern == patternEnd;
}	

/**




		return true; // null pattern is equivalent to '*'
	if (name == null)
		return false; // null name cannot match
	char[] patternChars = pattern.toCharArray();
	char nameChars[] = name.toCharArray();
	return CharOperation.camelCaseMatch(patternChars, 0, patternChars.length, nameChars, 0, nameChars.length);
}

/**

		return false; // null name cannot match
	if (pattern == null)
		return true; // null pattern is equivalent to '*'
	return CharOperation.camelCaseMatch(pattern.toCharArray(), patternStart, patternEnd, name.toCharArray(), nameStart, nameEnd);
	if (nameEnd < 0) nameEnd = name.length();

	if (patternEnd <= patternStart) return nameEnd <= nameStart;
	if (nameEnd <= nameStart) return false;
	// check first pattern char
	if (name.charAt(nameStart) != pattern.charAt(patternStart)) {
		// first char must strictly match (upper/lower)
		return false;
	}
	char patternChar, nameChar;
	int iPattern = patternStart+1;
	int iName = nameStart+1;
	nextPatternChar: while (iPattern < patternEnd) {
		// check patternChar, keep camelCasing only if uppercase
		if ((patternChar = pattern.charAt(iPattern)) < ScannerHelper.MAX_OBVIOUS) {
			if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {
				// end of camelCase part of pattern
				break nextPatternChar;
			}
			// still uppercase
		} else if (ScannerHelper.isJavaIdentifierPart(patternChar) 
						&& !ScannerHelper.isUpperCase(patternChar)) {
			// end of camelCase part of pattern
			break nextPatternChar;
		}
		nextNameChar: while (iName < nameEnd) {
			if ((nameChar = name.charAt(iName)) != patternChar) {
				if (nameChar < ScannerHelper.MAX_OBVIOUS) {
					if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER|ScannerHelper.C_SPECIAL |ScannerHelper.C_DIGIT)) != 0) {
						// lowercase/digit char is ignored
						iName++;
						continue nextNameChar;
					}
				} else if (ScannerHelper.isJavaIdentifierPart(nameChar) 
								&& !ScannerHelper.isUpperCase(nameChar)) {
					// lowercase name char is ignored
					iName++;
					continue nextNameChar;
				}
				// mismatch, either uppercase in name or non case char ('/' etc)--> reject
				return false;
			} else {
				// pattern char == name char (uppercase)
				iName++;
				iPattern++;
				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;
		}
		iPattern++;
		iName++;
	}
	return iPattern == patternEnd;
}	

/**

	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 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 283-341 Link Here

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

Lines 234-241 Link Here

(-)search/org/eclipse/jdt/core/search/SearchPattern.java (-81 / +8 lines)
234	return true; // null pattern is equivalent to '*'	234	return true; // null pattern is equivalent to '*'
235	if (name == null)	235	if (name == null)
236	return false; // null name cannot match	236	return false; // null name cannot match
237		237	char[] patternChars = pattern.toCharArray();
238	return camelCaseMatch(pattern, 0, pattern.length(), name, 0, name.length());	238	char nameChars[] = name.toCharArray();
		239	return CharOperation.camelCaseMatch(patternChars, 0, patternChars.length, nameChars, 0, nameChars.length);
239	}	240	}
240		241
241	/**	242	/**
Lines 297-365 Link Here
297	return false; // null name cannot match	298	return false; // null name cannot match
298	if (pattern == null)	299	if (pattern == null)
299	return true; // null pattern is equivalent to '*'	300	return true; // null pattern is equivalent to '*'
300	if (patternEnd < 0) patternEnd = pattern.length();	301	return CharOperation.camelCaseMatch(pattern.toCharArray(), patternStart, patternEnd, name.toCharArray(), nameStart, nameEnd);
301	if (nameEnd < 0) nameEnd = name.length();
302
303	if (patternEnd <= patternStart) return nameEnd <= nameStart;
304	if (nameEnd <= nameStart) return false;
305	// check first pattern char
306	if (name.charAt(nameStart) != pattern.charAt(patternStart)) {
307	// first char must strictly match (upper/lower)
308	return false;
309	}
310	char patternChar, nameChar;
311	int iPattern = patternStart+1;
312	int iName = nameStart+1;
313	nextPatternChar: while (iPattern < patternEnd) {
314	// check patternChar, keep camelCasing only if uppercase
315	if ((patternChar = pattern.charAt(iPattern)) < ScannerHelper.MAX_OBVIOUS) {
316	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {
317	// end of camelCase part of pattern
318	break nextPatternChar;
319	}
320	// still uppercase
321	} else if (ScannerHelper.isJavaIdentifierPart(patternChar)
322	&& !ScannerHelper.isUpperCase(patternChar)) {
323	// end of camelCase part of pattern
324	break nextPatternChar;
325	}
326	nextNameChar: while (iName < nameEnd) {
327	if ((nameChar = name.charAt(iName)) != patternChar) {
328	if (nameChar < ScannerHelper.MAX_OBVIOUS) {
329	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER\|ScannerHelper.C_SPECIAL \|ScannerHelper.C_DIGIT)) != 0) {
330	// lowercase/digit char is ignored
331	iName++;
332	continue nextNameChar;
333	}
334	} else if (ScannerHelper.isJavaIdentifierPart(nameChar)
335	&& !ScannerHelper.isUpperCase(nameChar)) {
336	// lowercase name char is ignored
337	iName++;
338	continue nextNameChar;
339	}
340	// mismatch, either uppercase in name or non case char ('/' etc)--> reject
341	return false;
342	} else {
343	// pattern char == name char (uppercase)
344	iName++;
345	iPattern++;
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	}
359	iPattern++;
360	iName++;
361	}
362	return iPattern == patternEnd;
363	}	302	}
364		303
365	/**	304	/**
Lines 1805-1826 Link Here
1805	if ((matchRule & R_CAMELCASE_MATCH) != 0) {	1744	if ((matchRule & R_CAMELCASE_MATCH) != 0) {
1806	// Verify sting pattern validity	1745	// Verify sting pattern validity
1807	int length = stringPattern.length();	1746	int length = stringPattern.length();
1808	boolean validCamelCase = false;	1747	boolean validCamelCase = true;
1809	if (length > 1) {	1748	for (int i=0; i<length && validCamelCase; i++) {
1810	int idx = 0;	1749	char ch = stringPattern.charAt(i++);
1811	char ch = stringPattern.charAt(idx++);	1750	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	}	1751	}
1825	// Verify bits compatibility	1752	// Verify bits compatibility
1826	if (validCamelCase) {	1753	if (validCamelCase) {