org.aspectj.asm.internal.NameConvertor Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aspectjtools Show documentation
Show all versions of aspectjtools Show documentation
AspectJ tools most notably contains the AspectJ compiler (AJC). AJC applies aspects to Java classes during
compilation, fully replacing Javac for plain Java classes and also compiling native AspectJ or annotation-based
@AspectJ syntax. Furthermore, AJC can weave aspects into existing class files in a post-compile binary weaving step.
This library is a superset of AspectJ weaver and hence also of AspectJ runtime.
/********************************************************************
* Copyright (c) 2006 Contributors. All rights reserved.
* This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v 2.0
* which accompanies this distribution and is available at
* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt
*
* 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;'
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;'
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;' it would return
* 'java.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;
}
}
// public static char[] createShortName(char[] c) {
// return createShortName(c, false);
// }
/**
* Given 'Ppkg/MyGenericClass<Ljava/lang/String;Ljava/lang/Integer;>;' will return 'QMyGenericClass<QString;QInteger;>;'
*/
public static char[] createShortName(char[] c, boolean haveFullyQualifiedAtLeastOneThing, boolean needsFullyQualifiedFirstEntry) {
if (c[0] == '[') {
char[] ret = CharOperation.concat(
new char[] { '\\', '[' },
createShortName(CharOperation.subarray(c, 1, c.length), haveFullyQualifiedAtLeastOneThing,
needsFullyQualifiedFirstEntry));
return ret;
} else if (c[0] == '+') {
char[] ret = CharOperation.concat(
new char[] { '+' },
createShortName(CharOperation.subarray(c, 1, c.length), haveFullyQualifiedAtLeastOneThing,
needsFullyQualifiedFirstEntry));
return ret;
} else if (c[0] == '*') {
return c; // c is *>;
}
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'
if (!needsFullyQualifiedFirstEntry) {
return getTypeName(c, true);
} else {
return getTypeName(c, haveFullyQualifiedAtLeastOneThing);
}
} else if (lt != -1 && (sc == -1 || lt <= sc) && (gt == -1 || lt <= gt)) {
// we have something like 'Ljava/lang/String;'
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 CharOperation.concat(createShortName(first, haveFullyQualifiedAtLeastOneThing, needsFullyQualifiedFirstEntry),
new char[] { ';' });
} else if (smallest == lt) {
// if c = 'Ljava/lang/String;