handleProvider = new OptimizedFullPathHandleProvider();
}
- public void createNewASM(INameConvertor convertor) {
+ public void createNewASM() {
hierarchy = new AspectJElementHierarchy();
- hierarchy.setNameConvertor(convertor);
mapper = new RelationshipMap(hierarchy);
}
public void flushHandleMap();
public void updateHandleMap(Set deletedFiles);
-
- public void setNameConvertor(INameConvertor convertor);
- public INameConvertor getNameConvertor();
}
\ No newline at end of file
+++ /dev/null
-/********************************************************************
- * 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;
-
-public interface INameConvertor {
-
- public char[] convertName(char[] name);
-
-}
protected IProgramElement root = null;
protected String configFile = null;
- private transient INameConvertor convertor = null;
private Map fileMap = null;
private Map handleMap = null;
return hid.substring(0,hid.indexOf("|"));
}
- public void setNameConvertor(INameConvertor convertor) {
- this.convertor = convertor;
- }
-
- public INameConvertor getNameConvertor() {
- return convertor;
- }
-
}
import org.aspectj.asm.AsmManager;
import org.aspectj.asm.HierarchyWalker;
-import org.aspectj.asm.INameConvertor;
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;
/**
List params = new ArrayList();
for (Iterator iter = l.iterator(); iter.hasNext();) {
char[] param = (char[])iter.next();
- INameConvertor convertor = AsmManager.getDefault().getHierarchy().getNameConvertor();
- if (convertor != null) {
- params.add(convertor.convertName(param));
- } else {
- params.add(param);
- }
+ params.add(NameConvertor.convertFromSignature(param));
}
return params;
}
import org.aspectj.ajdt.internal.compiler.problem.AjProblemReporter;
import org.aspectj.asm.AsmManager;
import org.aspectj.asm.IHierarchy;
-import org.aspectj.asm.INameConvertor;
import org.aspectj.asm.IProgramElement;
import org.aspectj.asm.internal.ProgramElement;
import org.aspectj.bridge.AbortException;
import org.aspectj.util.FileUtil;
import org.aspectj.weaver.Dump;
import org.aspectj.weaver.ResolvedType;
-import org.aspectj.weaver.TypeFactory;
-import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.World;
import org.aspectj.weaver.bcel.BcelWeaver;
import org.aspectj.weaver.bcel.BcelWorld;
AsmManager.setCreatingModel(config.isEmacsSymMode() || config.isGenerateModelMode());
if (!AsmManager.isCreatingModel()) return;
- AsmManager.getDefault().createNewASM(new NameConverter());
+ AsmManager.getDefault().createNewASM();
// AsmManager.getDefault().getRelationshipMap().clear();
IHierarchy model = AsmManager.getDefault().getHierarchy();
String rootLabel = "<root>";
}
}
-
- private class NameConverter implements INameConvertor {
-
- public char[] convertName(char[] name) {
- UnresolvedType ut = TypeFactory.createTypeFromSignature(new String(name));
- ResolvedType rt = getWorld().resolve(ut);
- return rt.getName().toCharArray();
- }
-
- }
}
element.wipeAllKnowledge();
}
incrementalStates.clear();
- AsmManager.getDefault().createNewASM(null); // forget what you know...
+ AsmManager.getDefault().createNewASM(); // forget what you know...
}
public static Set getConfigFilesKnown() {
import org.aspectj.asm.IProgramElement;
import org.aspectj.asm.internal.Relationship;
import org.aspectj.testing.XMLBasedAjcTestCase;
+import org.aspectj.util.CharOperation;
public class Ajc152Tests extends org.aspectj.testing.XMLBasedAjcTestCase {
assertNotNull("Couldn't find 'twoArgsMethod(int,java.lang.String)' element in the tree",twoArgsMethod);
List l = twoArgsMethod.getParameterSignatures();
assertEquals("",((char[])l.get(0))[0],'I');
- boolean eq = equals(((char[])l.get(1)),"Ljava/lang/String;".toCharArray());
+ boolean eq = CharOperation.equals(((char[])l.get(1)),"Ljava/lang/String;".toCharArray());
assertTrue("expected parameter to be 'Ljava/lang/String;' but found '" +
new String(((char[])l.get(1))) + "'",eq);
}
// ---------------- helper methods ---------------
- /**
- * taken from CharOperation
- */
- private 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;
- }
-
private void checkParametersForIPE(String ipeLabel, IProgramElement.Kind kind, String expectedParm, boolean getHandles) {
IHierarchy top = AsmManager.getDefault().getHierarchy();
IProgramElement ipe = top.findElementForLabel(top.getRoot(),kind,ipeLabel);
} else {
l = ipe.getParameterTypes();
}
- boolean eq = equals(((char[])l.get(0)),expectedParm.toCharArray());
+ boolean eq = CharOperation.equals(((char[])l.get(0)),expectedParm.toCharArray());
assertTrue("expected parameter to be '" + expectedParm + "' but found '" +
new String(((char[])l.get(0))) + "'",eq);
}
return -1;
}
+ /**
+ * 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;
+ }
+ }
+ }
}
--- /dev/null
+/********************************************************************
+ * 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.util;
+
+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[] 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[]{','};
+
+
+ /**
+ * 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;
+ }
+ }
+
+
+}
--- /dev/null
+/********************************************************************
+ * 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.util;
+
+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()));
+ }
+
+
+}
//$JUnit-BEGIN$
suite.addTestSuite(FileUtilTest.class);
suite.addTestSuite(LangUtilTest.class);
+ suite.addTestSuite(NameConvertorTest.class);
//$JUnit-END$
return suite;
}
projects / aspectj.git / commitdiff