diff options
author | aclement <aclement> | 2008-05-12 18:00:21 +0000 |
---|---|---|
committer | aclement <aclement> | 2008-05-12 18:00:21 +0000 |
commit | 5c49628e1936743d46eb9513e71af1e83ac8c6f4 (patch) | |
tree | e839a7499a8d0c4a30f3b22fb54b9a044e9fcb81 /asm | |
parent | 27c5c6324326f0126a121b76f9b543cdcfd4d0d1 (diff) | |
download | aspectj-5c49628e1936743d46eb9513e71af1e83ac8c6f4.tar.gz aspectj-5c49628e1936743d46eb9513e71af1e83ac8c6f4.zip |
231396: refactoring: Moved CharOperation and NameConvertor
Diffstat (limited to 'asm')
6 files changed, 419 insertions, 4 deletions
diff --git a/asm/src/org/aspectj/asm/internal/CharOperation.java b/asm/src/org/aspectj/asm/internal/CharOperation.java new file mode 100644 index 000000000..6432c3a88 --- /dev/null +++ b/asm/src/org/aspectj/asm/internal/CharOperation.java @@ -0,0 +1,116 @@ +/******************************************************************** + * Copyright (c) 2006 Contributors. All rights reserved. + * This program and the accompanying materials are made available + * under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution and is available at + * http://eclipse.org/legal/epl-v10.html + * + * Contributors: IBM Corporation - initial API and implementation + * Helen Hawkins - initial version + *******************************************************************/ +package org.aspectj.asm.internal; + + +/** + * Taken from org.aspectj.org.eclipse.jdt.core.compiler.CharOperation + * + */ +public class CharOperation { + + /** + * Taken from org.aspectj.org.eclipse.jdt.core.compiler.CharOperation + */ + public static final char[] subarray(char[] array, int start, int end) { + if (end == -1) + end = array.length; + if (start > end) + return null; + if (start < 0) + return null; + if (end > array.length) + return null; + + char[] result = new char[end - start]; + System.arraycopy(array, start, result, 0, end - start); + return result; + } + + /** + * Taken from org.aspectj.org.eclipse.jdt.core.compiler.CharOperation + */ + public static final int lastIndexOf(char toBeFound, char[] array) { + for (int i = array.length; --i >= 0;) + if (toBeFound == array[i]) + return i; + return -1; + } + +// /** +// * Taken from org.aspectj.org.eclipse.jdt.core.compiler.CharOperation +// */ +// public static final boolean contains(char character, char[] array) { +// for (int i = array.length; --i >= 0;) +// if (array[i] == character) +// return true; +// return false; +// } + + /** + * Taken from org.aspectj.org.eclipse.jdt.core.compiler.CharOperation + */ + public static final int indexOf(char toBeFound, char[] array) { + for (int i = 0; i < array.length; i++) + if (toBeFound == array[i]) + return i; + return -1; + } + + /** + * Taken from org.aspectj.org.eclipse.jdt.core.compiler.CharOperation + */ + public static final char[] concat(char[] first, char[] second) { + if (first == null) + return second; + if (second == null) + return first; + + int length1 = first.length; + int length2 = second.length; + char[] result = new char[length1 + length2]; + System.arraycopy(first, 0, result, 0, length1); + System.arraycopy(second, 0, result, length1, length2); + return result; + } + + /** + * Taken from org.aspectj.org.eclipse.jdt.core.compiler.CharOperation + */ + public static final boolean equals(char[] first, char[] second) { + if (first == second) + return true; + if (first == null || second == null) + return false; + if (first.length != second.length) + return false; + + for (int i = first.length; --i >= 0;) + if (first[i] != second[i]) + return false; + return true; + } + + /** + * Taken from org.aspectj.org.eclipse.jdt.core.compiler.CharOperation + */ + public static final void replace( + char[] array, + char toBeReplaced, + char replacementChar) { + if (toBeReplaced != replacementChar) { + for (int i = 0, max = array.length; i < max; i++) { + if (array[i] == toBeReplaced) + array[i] = replacementChar; + } + } + } +} diff --git a/asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java b/asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java index 712356e59..985c841c6 100644 --- a/asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java +++ b/asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java @@ -18,8 +18,6 @@ import org.aspectj.asm.AsmManager; import org.aspectj.asm.IElementHandleProvider; import org.aspectj.asm.IProgramElement; import org.aspectj.bridge.ISourceLocation; -import org.aspectj.util.CharOperation; -import org.aspectj.util.NameConvertor; /** * Creates JDT-like handles, for example diff --git a/asm/src/org/aspectj/asm/internal/NameConvertor.java b/asm/src/org/aspectj/asm/internal/NameConvertor.java new file mode 100644 index 000000000..bd4609979 --- /dev/null +++ b/asm/src/org/aspectj/asm/internal/NameConvertor.java @@ -0,0 +1,214 @@ +/******************************************************************** + * Copyright (c) 2006 Contributors. All rights reserved. + * This program and the accompanying materials are made available + * under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution and is available at + * http://eclipse.org/legal/epl-v10.html + * + * Contributors: IBM Corporation - initial API and implementation + * Helen Hawkins - initial version + *******************************************************************/ +package org.aspectj.asm.internal; + + +public class NameConvertor { + + private static final char BOOLEAN = 'Z'; + private static final char BYTE = 'B'; + private static final char CHAR = 'C'; + private static final char DOUBLE = 'D'; + private static final char FLOAT = 'F'; + private static final char INT = 'I'; + private static final char LONG = 'J'; + private static final char SHORT = 'S'; + private static final char ARRAY = '['; + private static final char RESOLVED = 'L'; + private static final char UNRESOLVED = 'Q'; + + public static final char PARAMETERIZED = 'P'; + + private static final char[] BOOLEAN_NAME = new char[]{'b','o','o','l','e','a','n'}; + private static final char[] BYTE_NAME = new char[]{'b','y','t','e'}; + private static final char[] CHAR_NAME = new char[]{'c','h','a','r'}; + private static final char[] DOUBLE_NAME = new char[]{'d','o','u','b','l','e'}; + private static final char[] FLOAT_NAME = new char[]{'f','l','o','a','t'}; + private static final char[] INT_NAME = new char[]{'i','n','t'}; + private static final char[] LONG_NAME = new char[]{'l','o','n','g'}; + private static final char[] SHORT_NAME = new char[]{'s','h','o','r','t'}; + + private static final char[] SQUARE_BRACKETS = new char[]{'[',']'}; + private static final char[] GREATER_THAN = new char[]{'>'}; + private static final char[] LESS_THAN = new char[]{'<'}; + private static final char[] COMMA = new char[]{','}; + private static final char[] BACKSLASH_LESSTHAN = new char[]{'\\','<'}; + private static final char[] SEMICOLON = new char[]{';'}; + + + /** + * Creates a readable name from the given char array, for example, + * given 'I' returns 'int'. Moreover, given + * 'Ljava/lang/String;<Ljava/lang/String;>' returns + * 'java.lang.String<java.lang.String>' + */ + public static char[] convertFromSignature(char[] c) { + int lt = CharOperation.indexOf('<',c); + int sc = CharOperation.indexOf(';',c); + int gt = CharOperation.indexOf('>',c); + + int smallest = 0; + if (lt == -1 && sc == -1 && gt == -1) { + // we have something like 'Ljava/lang/String' or 'I' + return getFullyQualifiedTypeName(c); + } else if (lt != -1 && (sc == -1 || lt <= sc) && (gt == -1 || lt <= gt)) { + // we have something like 'Ljava/lang/String<I' + smallest = lt; + } else if (sc != -1 && (lt == -1 || sc <= lt) && (gt == -1 || sc <= gt)) { + // we have something like 'Ljava/lang/String;I' + smallest = sc; + } else { + // we have something like '>;' + smallest = gt; + } + char[] first = CharOperation.subarray(c,0,smallest); + char[] second = CharOperation.subarray(c,smallest+1,c.length); + if (smallest == 0 && first.length == 0 && c[0] == '>') { + // c = {'>',';'} therefore we just want to return '>' to + // close the generic signature + return GREATER_THAN; + } else if (first.length == 1 && second.length == 0) { + return first; + } else if (second.length == 0 || (second.length == 1 && second[0] == ';')){ + // we've reached the end of the array, therefore only care about + // the first part + return convertFromSignature(first); + } else if (smallest == lt) { + // if c = 'Ljava/lang/String;<I' then first = 'Ljava/Lang/String;' and + // second = 'I'. Want to end up with 'Ljava.lang.String<I' and so add + // the '<' back. + char[] inclLT = CharOperation.concat(convertFromSignature(first),LESS_THAN); + return CharOperation.concat(inclLT,convertFromSignature(second)); + } else if (smallest == gt) { + char[] inclLT = CharOperation.concat(convertFromSignature(first),GREATER_THAN); + return CharOperation.concat(inclLT,convertFromSignature(second)); + } else if (second.length != 2) { + // if c = 'Ljava/lang/Sting;LMyClass' then first = 'Ljava/lang/String' + // and second = 'LMyClass'. Want to end up with 'java.lang.String,MyClass + // so want to add a ','. However, only want to do this if we're in the + // middle of a '<...>' + char[] inclComma = CharOperation.concat(convertFromSignature(first),COMMA); + return CharOperation.concat(inclComma,convertFromSignature(second)); + } + return CharOperation.concat(convertFromSignature(first),convertFromSignature(second)); + } + + + /** + * Given a char array, returns the type name for this. For example + * 'I' returns 'int', 'Ljava/lang/String' returns 'java.lang.String' and + * '[Ljava/lang/String' returns 'java.lang.String[]' + * + * NOTE: Doesn't go any deaper so given 'Ljava/lang/String;<Ljava/lang/String;>' + * it would return 'java.lang.String;<Ljava.lang.String;>', however, only called + * with something like 'Ljava/lang/String' + */ + private static char[] getFullyQualifiedTypeName(char[] c) { + if (c.length == 0) { + return c; + } + if (c[0] == BOOLEAN) { + return BOOLEAN_NAME; + } else if (c[0] == BYTE) { + return BYTE_NAME; + } else if (c[0] == CHAR) { + return CHAR_NAME; + } else if (c[0] == DOUBLE) { + return DOUBLE_NAME; + } else if (c[0] == FLOAT) { + return FLOAT_NAME; + } else if (c[0] == INT) { + return INT_NAME; + } else if (c[0] == LONG) { + return LONG_NAME; + } else if (c[0] == SHORT) { + return SHORT_NAME; + } else if (c[0] == ARRAY) { + return CharOperation.concat( + getFullyQualifiedTypeName(CharOperation.subarray(c,1,c.length)), + SQUARE_BRACKETS); + } else { + char[] type = CharOperation.subarray(c,1,c.length); + CharOperation.replace(type,'/','.'); + return type; + } + } + + /** + * Given 'Ppkg/MyGenericClass<Ljava/lang/String;Ljava/lang/Integer;>;' + * will return 'QMyGenericClass<QString;QInteger;>;' + */ + public static char[] createShortName(char[] c) { + int lt = CharOperation.indexOf('<',c); + int sc = CharOperation.indexOf(';',c); + int gt = CharOperation.indexOf('>',c); + + int smallest = 0; + if (lt == -1 && sc == -1 && gt == -1) { + // we have something like 'Ljava/lang/String' or 'I' + return getTypeName(c); + } else if (lt != -1 && (sc == -1 || lt <= sc) && (gt == -1 || lt <= gt)) { + // we have something like 'Ljava/lang/String<I' + smallest = lt; + } else if (sc != -1 && (lt == -1 || sc <= lt) && (gt == -1 || sc <= gt)) { + // we have something like 'Ljava/lang/String;I' + smallest = sc; + } else { + // we have something like '>;' + smallest = gt; + } + char[] first = CharOperation.subarray(c,0,smallest); + char[] second = CharOperation.subarray(c,smallest+1,c.length); + if (smallest == 0 && first.length == 0 && c[0] == '>') { + // c = {'>',';'} therefore we just want to return c to + // close the generic signature + return c; + } else if (first.length == 1 && second.length == 0) { + return first; + } else if (second.length == 0 || (second.length == 1 && second[0] == ';')){ + // we've reached the end of the array, therefore only care about + // the first part + return createShortName(first); + } else if (smallest == lt) { + // if c = 'Ljava/lang/String;<I' then first = 'Ljava/Lang/String;' and + // second = 'I'. Want to end up with 'LString<I' and so add + // the '<' back. + char[] inclLT = CharOperation.concat(createShortName(first),BACKSLASH_LESSTHAN); + return CharOperation.concat(inclLT,createShortName(second)); + } else if (smallest == gt) { + char[] inclLT = CharOperation.concat(createShortName(first),GREATER_THAN); + return CharOperation.concat(inclLT,createShortName(second)); + } else { + // if c = 'Ljava/lang/Sting;LMyClass;' then first = 'Ljava/lang/String' + // and second = 'LMyClass;'. Want to end up with 'QString;QMyClass; + // so add the ';' back + char[] firstTypeParam = CharOperation.concat(createShortName(first),SEMICOLON); + return CharOperation.concat(firstTypeParam,createShortName(second)); + } + } + + /** + * Given 'Qjava/lang/String;' returns 'QString;' + */ + public static char[] getTypeName(char[] name) { + int i = CharOperation.lastIndexOf('/',name); + if (i != -1) { + if (name[0] == RESOLVED || name[0] == PARAMETERIZED) { + return CharOperation.concat(new char[]{UNRESOLVED}, + CharOperation.subarray(name,i+1,name.length)); + } else { + return CharOperation.concat(new char[]{name[0]}, + CharOperation.subarray(name,i+1,name.length)); + } + } + return name; + } +} diff --git a/asm/src/org/aspectj/asm/internal/ProgramElement.java b/asm/src/org/aspectj/asm/internal/ProgramElement.java index 7bf2b3e44..189133935 100644 --- a/asm/src/org/aspectj/asm/internal/ProgramElement.java +++ b/asm/src/org/aspectj/asm/internal/ProgramElement.java @@ -25,8 +25,6 @@ import org.aspectj.asm.HierarchyWalker; import org.aspectj.asm.IProgramElement; import org.aspectj.bridge.IMessage; import org.aspectj.bridge.ISourceLocation; -import org.aspectj.util.CharOperation; -import org.aspectj.util.NameConvertor; /** diff --git a/asm/testsrc/org/aspectj/asm/AsmModuleTests.java b/asm/testsrc/org/aspectj/asm/AsmModuleTests.java index 52f424d99..ebb500911 100644 --- a/asm/testsrc/org/aspectj/asm/AsmModuleTests.java +++ b/asm/testsrc/org/aspectj/asm/AsmModuleTests.java @@ -15,6 +15,8 @@ package org.aspectj.asm; // default package +import org.aspectj.asm.NameConvertorTest; + import junit.framework.*; public class AsmModuleTests extends TestCase { @@ -22,6 +24,7 @@ public class AsmModuleTests extends TestCase { public static TestSuite suite() { TestSuite suite = new TestSuite(AsmModuleTests.class.getName()); suite.addTestSuite(AsmModuleTests.class); + suite.addTestSuite(NameConvertorTest.class); return suite; } diff --git a/asm/testsrc/org/aspectj/asm/NameConvertorTest.java b/asm/testsrc/org/aspectj/asm/NameConvertorTest.java new file mode 100644 index 000000000..c1162eed2 --- /dev/null +++ b/asm/testsrc/org/aspectj/asm/NameConvertorTest.java @@ -0,0 +1,86 @@ +/******************************************************************** + * Copyright (c) 2006 Contributors. All rights reserved. + * This program and the accompanying materials are made available + * under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution and is available at + * http://eclipse.org/legal/epl-v10.html + * + * Contributors: IBM Corporation - initial API and implementation + * Helen Hawkins - initial version + *******************************************************************/ +package org.aspectj.asm; + +import org.aspectj.asm.internal.CharOperation; +import org.aspectj.asm.internal.NameConvertor; + +import junit.framework.TestCase; + +public class NameConvertorTest extends TestCase { + + public void testBoolean() { + checkConversion("Z","boolean"); + } + + public void testByte() { + checkConversion("B","byte"); + } + + public void testChar() { + checkConversion("C","char"); + } + + public void testDouble() { + checkConversion("D","double"); + } + + public void testFloat() { + checkConversion("F","float"); + } + + public void testInt() { + checkConversion("I","int"); + } + + public void testLong() { + checkConversion("J","long"); + } + + public void testShort() { + checkConversion("S","short"); + } + + public void testString() { + checkConversion("Ljava/lang/String;","java.lang.String"); + } + + public void testType() { + checkConversion("LMyClass;","MyClass"); + } + + public void testListPameterizedWithString() { + checkConversion("Pjava/util/List<Ljava/lang/String;>;", + "java.util.List<java.lang.String>"); + } + public void testClassParameterizedWithStringAndType() { + checkConversion("PMyGenericClass<Ljava/lang/String;LMyClass;>;", + "MyGenericClass<java.lang.String,MyClass>"); + } + public void testStringArray() { + checkConversion("[Ljava/lang/String;","java.lang.String[]"); + } + public void testTwoDimensionalStringArray() { + checkConversion("[[Ljava/lang/String;","java.lang.String[][]"); + } + public void testIntArray() { + checkConversion("[I","int[]"); + } + + private void checkConversion(String signature, String expected) { + char[] c = NameConvertor.convertFromSignature(signature.toCharArray()); + assertTrue("converting " + signature + ", expected " + expected + "," + + "but found " + String.valueOf(c), + CharOperation.equals(c,expected.toCharArray())); + } + + +} |