org.jikesrvm.classloader

Class TypeDescriptorParsing

java.lang.Object

org.jikesrvm.classloader.TypeDescriptorParsing

public abstract class TypeDescriptorParsing
extends Object

A Java class for parsing type descriptors and class names. The class is abstract to eliminate the temptation to instantiate it, since it contains only static methods.

There are five similar kinds of descriptors and names that we have to deal with. We don't have methods for parsing all of them.

In this documentation, I will refer to The Java Native Interface Programmer's Guide and Specification as the JNI Guide.

Some of the types I discuss below are described in 12.3 of the JNI Guide.

Fully-qualified class names and fully-qualified interface names

These are the dot-separated names, such as "java.lang.String" or "java.util.Map".

We can validate these with the static method #isJavaClassName(String) in this class.

JNI Class Descriptor (including array classes),
These include the internal Form of fully-qualified class names and internal form of fully-qualified interface names

These

“It can be derived from a fully qualified class or interface name as defined in The Java Language Specification by substituting the "." character with the "/" character. For example, the JNI class descriptor for java.lang.String is "java/lang/String” Array classes are formed using the "[" character followed by the field descriptor of the element type. The class descrpitor for "int[]" is "[I".

We do not have an interface for parsing these right now.

Field Descriptors

Described in 12.3.3 of the JNI Guide. Examples:

• "Z" for boolean
  
• "B" for byte
• "D" for double
• "Ljava/lang/String;" for java.lang.String
• "[I" for int[].

Method Descriptors

Described in 12.3.4 of the JNI guide. To quote:

Method Descriptors are formed by placing the field descriptors of all argument types in a pair of parentheses, and following that by the field descriptor of the return type. There are no spaces or other separator characters between the argument types. "V" is used to denote the void method return type. Constructors use "V" as their return type and use "<init>" as their name.

Example: The method with signature "byte f(int i, String s)" has the Method Descriptor "(ILjava/lang/String;)B"

TypeReference names

Inside Jikes RVM, we use the TypeReference class to represent the reference in some class file to some type (class, interface, primitive, or array). We also use them to represent Void (TypeReference.Void). TypeReference names are just field descriptors plus "V".

Constructor Summary

Constructors

Constructor and Description
TypeDescriptorParsing()

Method Summary

Modifier and Type	Method and Description
static boolean	isJavaClassName(String s) Is the string s a legal name for a Java class or interface?
static boolean	isJavaClassNameInternalForm(char[] val, int first, int last) Is this the internal form of a Java class name?
private static boolean	isJavaPrimitive(byte b)
private static boolean	isJavaPrimitive(char c)
static boolean	isValidTypeDescriptor(Atom a)
static boolean	isValidTypeDescriptor(String s)
static boolean	isVMIdentifierPart(char c) Java 1.5 relaxes the historical convention that class file identifiers (i.e. class, field, and method names) must be drawn from the characters specified by JLS identifiers (i.e. implemented by java.lang.Character.isJavaIdentifierPart()).
static boolean	isVMIdentifierStart(char c) Java 1.5 relaxes the historical convention that class file identifiers (i.e. class, field, and method names) must be drawn from the characters specified by JLS identifiers (i.e. implemented by java.lang.Character.isJavaIdentifierStart()).
private static void	malformed(String msg, String typeName)
static void	validateAsTypeDescriptor(Atom a)
static void	validateAsTypeDescriptor(String s) Validates that the given String is a valid type descriptor.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TypeDescriptorParsing

public TypeDescriptorParsing()

Method Detail

isJavaClassName

public static boolean isJavaClassName(String s)

Is the string s a legal name for a Java class or interface? This will take either fully-qualified names or names that are not fully qualified.

Parameters:

s - The string to check for whether it's a valid name for a Java class. This is a string of the form, for example: "java.lang.String"

Returns:

true if s is valid, false otherwise.

Implementation Question for wiser heads than mine: Would it be more efficient for me to convert this to a char array? That's the way the example in The Java Class Libraries for Character.isJavaIdentifier*() is written. Or is the String.charAt() method inexpensive?

isVMIdentifierStart

public static boolean isVMIdentifierStart(char c)

Java 1.5 relaxes the historical convention that class file identifiers (i.e. class, field, and method names) must be drawn from the characters specified by JLS identifiers (i.e. implemented by java.lang.Character.isJavaIdentifierStart()).

Given that, parsing rules for internal and external VM identifier dictates that identifiers may not contain the following characters: { '.', ';', '[', or '/' }. Method identifiers, excluding <init> and <clinit>, are further constrained to not include the characters '<' or '>'.

To avoid word boundary ambiguity, identifiers are presumed to not begin with a space character. Although not stated explicitly, this remains convention.

This method evaluates whether c is compatible as the starting character for a VM identifier.

Parameters:

c - character to evaluate for VM identifier compatibility

Returns:

boolean true iff c represents a valid VM identifier starting character

isVMIdentifierPart

public static boolean isVMIdentifierPart(char c)

Java 1.5 relaxes the historical convention that class file identifiers (i.e. class, field, and method names) must be drawn from the characters specified by JLS identifiers (i.e. implemented by java.lang.Character.isJavaIdentifierPart()).

Given that, parsing rules for internal and external VM identifier dictates that identifiers may not contain the following characters: { '.', ';', '[', or '/' }. Method identifiers, excluding <init> and <clinit>, are further constrained to not include the characters '<' or '>'.

This method evaluates whether c is compatible as a non-starting character for a VM identifier.

Parameters:

c - character to evaluate for VM identifier compatibility

Returns:

boolean true iff c represents a valid VM identifier non-starting character

isJavaClassNameInternalForm

public static boolean isJavaClassNameInternalForm(char[] val,
                                                  int first,
                                                  int last)

Is this the internal form of a Java class name? (the one with the "/" instead of the "." separating components?)

Parameters:

val - a string as a char array

first - the start index of the string to be checked

last - the last index of the string to be checked

Returns:

true if the given char array represents an internal java class name

isValidTypeDescriptor

public static boolean isValidTypeDescriptor(String s)

isValidTypeDescriptor

public static boolean isValidTypeDescriptor(Atom a)

validateAsTypeDescriptor

public static void validateAsTypeDescriptor(Atom a)
                                     throws IllegalArgumentException

Throws:

IllegalArgumentException

validateAsTypeDescriptor

public static void validateAsTypeDescriptor(String s)
                                     throws IllegalArgumentException

Validates that the given String is a valid type descriptor.

Parameters:

s - string to check

Throws:

IllegalArgumentException - if the string is not a valid type descriptor

isJavaPrimitive

private static boolean isJavaPrimitive(char c)

isJavaPrimitive

private static boolean isJavaPrimitive(byte b)

malformed

private static void malformed(String msg,
                              String typeName)
                       throws IllegalArgumentException

Throws:

IllegalArgumentException