Attachment 39389 Details for Bug 138167 – Proposed fix

[patch] Proposed fix

patch_138167.txt (text/plain), 10.91 KB, created by Olivier Thomann

on 2006-04-24 23:56:09 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Olivier Thomann

Created: 2006-04-24 23:56:09 EDT

Size: 10.91 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core
>Index: model/org/eclipse/jdt/internal/core/BinaryMethod.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/BinaryMethod.java,v
>retrieving revision 1.87
>diff -u -r1.87 BinaryMethod.java
>--- model/org/eclipse/jdt/internal/core/BinaryMethod.java	6 Apr 2006 01:47:51 -0000	1.87
>+++ model/org/eclipse/jdt/internal/core/BinaryMethod.java	25 Apr 2006 03:37:01 -0000
>@@ -25,6 +25,15 @@
>  */
> 
> /* package */ class BinaryMethod extends BinaryMember implements IMethod {
>+	private static final char[] BOOLEAN = "boolean".toCharArray(); //$NON-NLS-1$
>+	private static final char[] BYTE = "byte".toCharArray(); //$NON-NLS-1$
>+	private static final char[] CHAR = "char".toCharArray(); //$NON-NLS-1$
>+	private static final char[] DOUBLE = "double".toCharArray(); //$NON-NLS-1$
>+	private static final char[] FLOAT = "float".toCharArray(); //$NON-NLS-1$
>+	private static final char[] INT = "int".toCharArray(); //$NON-NLS-1$
>+	private static final char[] LONG = "long".toCharArray(); //$NON-NLS-1$
>+	private static final char[] SHORT = "short".toCharArray(); //$NON-NLS-1$
>+	private static final char[] VOID = "void".toCharArray(); //$NON-NLS-1$
> 
> 	/**
> 	 * The parameter type signatures of the method - stored locally
>@@ -491,7 +500,15 @@
> 	if (this.isConstructor()) {
> 		methodName = typeQualifiedName;
> 	}
>-	String anchor = Signature.toString(this.getSignature().replace('/', '.'), methodName, null, true, false, Flags.isVarargs(this.getFlags()));
>+	IBinaryMethod info = (IBinaryMethod) getElementInfo();
>+	char[] genericSignature = info.getGenericSignature();
>+	String anchor = null;
>+	if (genericSignature != null) {
>+		CharOperation.replace(genericSignature, '/', '.');
>+		anchor = toString(genericSignature, methodName, Flags.isVarargs(this.getFlags()));
>+	} else {
>+		anchor = Signature.toString(this.getSignature().replace('/', '.'), methodName, null, true, false, Flags.isVarargs(this.getFlags()));
>+	}
> 	if (declaringTypeIsMember) {
> 
> 		int depth = 0;
>@@ -544,4 +561,305 @@
> 	if (indexOfNextMethod == -1) throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.UNKNOWN_JAVADOC_FORMAT, this));
> 	return contents.substring(indexOfEndLink + JavadocConstants.ANCHOR_SUFFIX_LENGTH, indexOfNextMethod);
> }
>+public String toString(char[] methodSignature, String methodName, boolean isVarArgs) {
>+	return new String(toCharArray(methodSignature, methodName.toCharArray(), isVarArgs));
>+}
>+public char[] toCharArray(char[] methodSignature, char[] methodName, boolean isVargArgs) {
>+	int firstParen = CharOperation.indexOf(Signature.C_PARAM_START, methodSignature);
>+	if (firstParen == -1) {
>+		throw new IllegalArgumentException();
>+	}
>+	
>+	StringBuffer buffer = new StringBuffer(methodSignature.length + 10);
>+
>+	// selector
>+	if (methodName != null) {
>+		buffer.append(methodName);
>+	}
>+	
>+	// parameters
>+	buffer.append('(');
>+	char[][] pts = getParameterTypes(methodSignature);
>+	for (int i = 0, max = pts.length; i < max; i++) {
>+		if (i == max - 1) {
>+			appendTypeSignature(pts[i], 0 , buffer, isVargArgs);
>+		} else {
>+			appendTypeSignature(pts[i], 0 , buffer, false);
>+		}
>+		if (i != pts.length - 1) {
>+			buffer.append(',');
>+			buffer.append(' ');
>+		}
>+	}
>+	buffer.append(')');
>+	char[] result = new char[buffer.length()];
>+	buffer.getChars(0, buffer.length(), result, 0);
>+	return result;
>+}
>+public char[][] getParameterTypes(char[] methodSignature) throws IllegalArgumentException {
>+	try {
>+		int count = getParameterCount(methodSignature);
>+		char[][] result = new char[count][];
>+		if (count == 0) {
>+			return result;
>+		}
>+		int i = CharOperation.indexOf(Signature.C_PARAM_START, methodSignature);
>+		if (i < 0) {
>+			throw new IllegalArgumentException();
>+		} else {
>+			i++;
>+		}
>+		int t = 0;
>+		for (;;) {
>+			if (methodSignature[i] == Signature.C_PARAM_END) {
>+				return result;
>+			}
>+			int e = Util.scanTypeSignature(methodSignature, i);
>+			if (e < 0) {
>+				throw new IllegalArgumentException();
>+			}
>+			result[t] = CharOperation.subarray(methodSignature, i, e + 1);
>+			t++;
>+			i = e + 1;
>+		}
>+	} catch (ArrayIndexOutOfBoundsException e) {
>+		throw new IllegalArgumentException();
>+	}
>+}
>+private int appendTypeSignature(char[] string, int start, StringBuffer buffer, boolean isVarArgs) {
>+	// need a minimum 1 char
>+	if (start >= string.length) {
>+		throw new IllegalArgumentException();
>+	}
>+	char c = string[start];
>+	if (isVarArgs) {
>+		switch (c) {
>+			case Signature.C_ARRAY :
>+				return appendArrayTypeSignature(string, start, buffer, true);
>+			case Signature.C_RESOLVED :
>+			case Signature.C_TYPE_VARIABLE :
>+			case Signature.C_BOOLEAN :
>+			case Signature.C_BYTE :
>+			case Signature.C_CHAR :
>+			case Signature.C_DOUBLE :
>+			case Signature.C_FLOAT :
>+			case Signature.C_INT :
>+			case Signature.C_LONG :
>+			case Signature.C_SHORT :
>+			case Signature.C_VOID :
>+			case Signature.C_STAR:
>+			case Signature.C_EXTENDS:
>+			case Signature.C_SUPER:
>+			case Signature.C_CAPTURE:
>+			default:
>+				throw new IllegalArgumentException(); // a var args is an array type
>+		}
>+	} else {
>+		switch (c) {
>+			case Signature.C_ARRAY :
>+				return appendArrayTypeSignature(string, start, buffer, false);
>+			case Signature.C_RESOLVED :
>+				return appendClassTypeSignature(string, start, buffer);
>+			case Signature.C_TYPE_VARIABLE :
>+				int e = Util.scanTypeVariableSignature(string, start);
>+				buffer.append(string, start + 1, e - start - 1);
>+				return e;
>+			case Signature.C_BOOLEAN :
>+				buffer.append(BOOLEAN);
>+				return start;
>+			case Signature.C_BYTE :
>+				buffer.append(BYTE);
>+				return start;
>+			case Signature.C_CHAR :
>+				buffer.append(CHAR);
>+				return start;
>+			case Signature.C_DOUBLE :
>+				buffer.append(DOUBLE);
>+				return start;
>+			case Signature.C_FLOAT :
>+				buffer.append(FLOAT);
>+				return start;
>+			case Signature.C_INT :
>+				buffer.append(INT);
>+				return start;
>+			case Signature.C_LONG :
>+				buffer.append(LONG);
>+				return start;
>+			case Signature.C_SHORT :
>+				buffer.append(SHORT);
>+				return start;
>+			case Signature.C_VOID :
>+				buffer.append(VOID);
>+				return start;
>+			case Signature.C_CAPTURE :
>+				return appendCaptureTypeSignature(string, start, buffer);
>+			case Signature.C_STAR:
>+			case Signature.C_EXTENDS:
>+			case Signature.C_SUPER:
>+				return appendTypeArgumentSignature(string, start, buffer);
>+			default :
>+				throw new IllegalArgumentException();
>+		}
>+	}
>+}
>+public int getParameterCount(char[] methodSignature) throws IllegalArgumentException {
>+	try {
>+		int count = 0;
>+		int i = CharOperation.indexOf(Signature.C_PARAM_START, methodSignature);
>+		if (i < 0) {
>+			throw new IllegalArgumentException();
>+		} else {
>+			i++;
>+		}
>+		for (;;) {
>+			if (methodSignature[i] == Signature.C_PARAM_END) {
>+				return count;
>+			}
>+			int e= Util.scanTypeSignature(methodSignature, i);
>+			if (e < 0) {
>+				throw new IllegalArgumentException();
>+			} else {
>+				i = e + 1;
>+			}
>+			count++;
>+		}
>+	} catch (ArrayIndexOutOfBoundsException e) {
>+		throw new IllegalArgumentException();
>+	}
>+}
>+private int appendArrayTypeSignature(char[] string, int start, StringBuffer buffer, boolean isVarArgs) {
>+	int length = string.length;
>+	// need a minimum 2 char
>+	if (start >= length - 1) {
>+		throw new IllegalArgumentException();
>+	}
>+	char c = string[start];
>+	if (c != Signature.C_ARRAY) {
>+		throw new IllegalArgumentException();
>+	}
>+	
>+	int index = start;
>+	c = string[++index];
>+	while(c == Signature.C_ARRAY) {
>+		// need a minimum 2 char
>+		if (index >= length - 1) {
>+			throw new IllegalArgumentException();
>+		}
>+		c = string[++index];
>+	}
>+	
>+	int e = appendTypeSignature(string, index, buffer, false);
>+	
>+	for(int i = 1, dims = index - start; i < dims; i++) {
>+		buffer.append('[').append(']');
>+	}
>+	
>+	if (isVarArgs) {
>+		buffer.append('.').append('.').append('.');
>+	} else {
>+		buffer.append('[').append(']');
>+	}
>+	return e;
>+}
>+private int appendClassTypeSignature(char[] string, int start, StringBuffer buffer) {
>+	// need a minimum 3 chars "Lx;"
>+	if (start >= string.length - 2) { 
>+		throw new IllegalArgumentException();
>+	}
>+	// must start in "L" or "Q"
>+	char c = string[start];
>+	if (c != Signature.C_RESOLVED && c != Signature.C_UNRESOLVED) {
>+		throw new IllegalArgumentException();
>+	}
>+	int p = start + 1;
>+	while (true) {
>+		if (p >= string.length) {
>+			throw new IllegalArgumentException();
>+		}
>+		c = string[p];
>+		switch(c) {
>+			case Signature.C_SEMICOLON :
>+				// all done
>+				return p;
>+			case Signature.C_GENERIC_START :
>+				int e = searchGenericEnd(string, p + 1);
>+				// once we hit type arguments there are no more package prefixes
>+				p = e;
>+				break;
>+			case Signature.C_DOT :
>+				buffer.append('.');
>+				break;
>+			 case '/' :
>+				buffer.append('/');
>+				break;
>+			 case Signature.C_DOLLAR :
>+				// once we hit "$" there are no more package prefixes
>+				/**
>+				 * Convert '$' in resolved type signatures into '.'.
>+				 * NOTE: This assumes that the type signature is an inner type
>+				 * signature. This is true in most cases, but someone can define a
>+				 * non-inner type name containing a '$'.
>+				 */
>+				buffer.append('.');
>+			 	break;
>+			 default :
>+				buffer.append(c);
>+		}
>+		p++;
>+	}
>+}
>+private int appendTypeArgumentSignature(char[] string, int start, StringBuffer buffer) {
>+	// need a minimum 1 char
>+	if (start >= string.length) {
>+		throw new IllegalArgumentException();
>+	}
>+	char c = string[start];
>+	switch(c) {
>+		case Signature.C_STAR :
>+			return start;
>+		case Signature.C_EXTENDS :
>+			return appendTypeSignature(string, start + 1, buffer, false);
>+		case Signature.C_SUPER :
>+			return appendTypeSignature(string, start + 1, buffer, false);
>+		default :
>+			return appendTypeSignature(string, start, buffer, false);
>+	}
>+}
>+private int appendCaptureTypeSignature(char[] string, int start, StringBuffer buffer) {
>+	// need a minimum 2 char
>+	if (start >= string.length - 1) {
>+		throw new IllegalArgumentException();
>+	}
>+	char c = string[start];
>+	if (c != Signature.C_CAPTURE) {
>+		throw new IllegalArgumentException();
>+	}
>+	return appendTypeArgumentSignature(string, start + 1, buffer);
>+}
>+private int searchGenericEnd(char[] string, int start) {
>+	if (start >= string.length) {
>+		throw new IllegalArgumentException();
>+	}
>+	if (string[start] == Signature.C_GENERIC_END) {
>+		return start;
>+	}
>+	int length = string.length;
>+	int balance = 1;
>+	start++;
>+	while (start <= length) {
>+		switch(string[start]) {
>+			case Signature.C_GENERIC_END :
>+				balance--;
>+				if (balance == 0) {
>+					return start;
>+				}
>+				break;
>+			case Signature.C_GENERIC_START :
>+				balance++;
>+				break;
>+		}
>+		start++;
>+	}
>+	return start;
>+}
> }

Actions: View | Diff

Attachments on bug 138167: 39389 | 39421 | 39464 | 39534