/*
* Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* Licensed Materials - Property of IBM
* RMI-IIOP v1.0
* Copyright IBM Corp. 1998 1999 All Rights Reserved
*
*/
package sun.rmi.rmic.iiop;
import java.util.Hashtable;
import java.util.Locale;
import sun.tools.java.Identifier;
import sun.tools.java.CompilerError;
import sun.tools.java.ClassDefinition;
import sun.tools.java.ClassNotFound;
import com.sun.corba.se.impl.util.RepositoryId;
/**
* IDLNames provides static utility methods to perform the IDL
* name mappings specified in Chapter 5 of the Java Language
* to IDL specification.
*
* @author Bryan Atsatt
*/
public class IDLNames implements sun.rmi.rmic.iiop.Constants {
/**
* Used to convert ascii to hex.
*/
public static final byte ASCII_HEX[] = {
(byte)'0',
(byte)'1',
(byte)'2',
(byte)'3',
(byte)'4',
(byte)'5',
(byte)'6',
(byte)'7',
(byte)'8',
(byte)'9',
(byte)'A',
(byte)'B',
(byte)'C',
(byte)'D',
(byte)'E',
(byte)'F',
};
// Legal IDL Identifier characters (1 = legal). Note
// that '.' (2E) is marked as legal even though it is
// not legal in IDL. This allows us to treat a fully
// qualified Java name with '.' package separators
// uniformly, and is safe because that is the only
// legal use of '.' in a Java name.
private static final byte[] IDL_IDENTIFIER_CHARS = {
// 0 1 2 3 4 5 6 7 8 9 a b c d e f
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, // 00-0f
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, // 10-1f
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,1,0, // 20-2f
1,1,1,1, 1,1,1,1, 1,1,0,0, 0,0,0,0, // 30-3f
0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, // 40-4f
1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,1, // 50-5f
0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, // 60-6f
1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0, // 70-7f
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, // 80-8f
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, // 90-9f
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, // a0-af
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, // b0-bf
1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, // c0-cf
0,1,1,1, 1,1,1,0, 1,1,1,1, 1,0,0,1, // d0-df
1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, // e0-ef
0,1,1,1, 1,1,1,0, 1,1,1,1, 1,0,0,1, // f0-ff
};
//_____________________________________________________________________
// Public Interfaces
//_____________________________________________________________________
/**
* Convert a name. The nameContext argument MUST be pre-filled with
* all names from the appropriate context (e.g. all the method names
* in a given class). The names must not have had any IDL conversions
* applied.
* <p>
* Section 28.3.2.2
* Section 28.3.2.3
* Section 28.3.2.4
* Section 28.3.2.7 (member and method names only)
*/
public static String getMemberOrMethodName (NameContext nameContext,
String name,
BatchEnvironment env) {
// Check namesCache...
String result = (String) env.namesCache.get(name);
if (result == null) {
// 28.3.2.7 Case sensitive member names.
// Note: This must be done before any of
// the other conversions!
result = nameContext.get(name);
// 28.3.2.3 Leading underscores...
result = convertLeadingUnderscores(result);
// 28.3.2.2 IDL keywords (NOTE: must be done
// after leading underscore conversion because
// the mangling for IDL keywords creates a
// leading underscore!)...
result = convertIDLKeywords(result);
// 28.3.2.4 Illegal IDL identifier characters...
result = convertToISOLatin1(result);
// Add to namesCache...
env.namesCache.put(name,result);
}
return result;
}
/**
* Convert names with illegal IDL identifier characters.
* <p>
* Section 28.3.2.4
*/
public static String convertToISOLatin1 (String name) {
// First, replace any escape sequences...
String result = replace(name,"x\\u","U");
result = replace(result,"x\\U","U");
// Now see if we have any remaining illegal characters (see
// IDL_IDENTIFIER_CHARS array)...
int length = result.length();
StringBuffer buffer = null;
for (int i = 0; i < length; i++) {
char c = result.charAt(i);
if (c > 255 || IDL_IDENTIFIER_CHARS[c] == 0) {
// We gotta convert. Have we already started?
if (buffer == null) {
// No, so get set up...
buffer = new StringBuffer(result.substring(0,i));
}
// Convert the character into the IDL escape syntax...
buffer.append("U");
buffer.append((char)ASCII_HEX[(c & 0xF000) >>> 12]);
buffer.append((char)ASCII_HEX[(c & 0x0F00) >>> 8]);
buffer.append((char)ASCII_HEX[(c & 0x00F0) >>> 4]);
buffer.append((char)ASCII_HEX[(c & 0x000F)]);
} else {
if (buffer != null) {
buffer.append(c);
}
}
}
if (buffer != null) {
result = buffer.toString();
}
return result;
}
/**
* Convert names which collide with IDL keywords.
* <p>
* Section 28.3.2.5
*/
public static String convertIDLKeywords (String name) {
for (int i = 0; i < IDL_KEYWORDS.length; i++) {
if (name.equalsIgnoreCase(IDL_KEYWORDS[i])) {
return "_" + name;
}
}
return name;
}
/**
* Convert names which have leading underscores
* <p>
* Section 28.3.2.3
*/
public static String convertLeadingUnderscores (String name) {
if (name.startsWith("_")) {
return "J" + name;
}
return name;
}
/**
* Convert a type name.
* <p>
* Section 28.3.2.5
* Section 28.3.2.7 (class or interface names only)
* Throws exception if fails 28.3.2.7.
*/
public static String getClassOrInterfaceName (Identifier id,
BatchEnvironment env) throws Exception {
// Get the type and package name...
String typeName = id.getName().toString();
String packageName = null;
if (id.isQualified()) {
packageName = id.getQualifier().toString();
}
// Check namesCache...
String result = (String) env.namesCache.get(typeName);
if (result == null) {
// 28.3.2.5 Inner classes...
result = replace(typeName,". ","__");
// 28.3.2.4 Illegal identifier characters...
result = convertToISOLatin1(result);
// 28.3.2.7 Case sensitive class or interface names...
NameContext context = NameContext.forName(packageName,false,env);
context.assertPut(result);
// Run it through the name checks...
result = getTypeOrModuleName(result);
// Add it to the namesCache...
env.namesCache.put(typeName,result);
}
return result;
}
/**
* Convert an Exception name.
* <p>
* Section 28.3.7.2 (see ValueType)
*/
public static String getExceptionName (String idlName) {
String result = idlName;
// d.11315 Incorrectly mangled exception names
if (idlName.endsWith(EXCEPTION_SUFFIX)) {
// Remove "Exception" and append "Ex". Strip leading underscore
// in case the idlName is exactly "_Exception"...
result = stripLeadingUnderscore(idlName.substring(0,idlName.lastIndexOf(EXCEPTION_SUFFIX)) + EX_SUFFIX);
} else {
result = idlName + EX_SUFFIX;
}
return result;
}
/**
* Convert a qualified Identifier into an array of IDL names.
* <p>
* Section 28.3.2.1 (see CompoundType)
* Throws exception if fails 28.3.2.7.
*/
public static String[] getModuleNames (Identifier theID,
boolean boxIt,
BatchEnvironment env) throws Exception {
String[] result = null;
if (theID.isQualified()) {
// Extract the qualifier...
Identifier id = theID.getQualifier();
// 28.3.2.7 Case sensitive module names.
env.modulesContext.assertPut(id.toString());
// Count them...
int count = 1;
Identifier current = id;
while (current.isQualified()) {
current = current.getQualifier();
count++;
}
result = new String[count];
int index = count-1;
current = id;
// Now walk them and fill our array (backwards)...
for (int i = 0; i < count; i++) {
String item = current.getName().toString();
// Check namesCache...
String cachedItem = (String) env.namesCache.get(item);
if (cachedItem == null) {
// 28.3.2.4 Illegal identifier characters...
cachedItem = convertToISOLatin1(item);
// Run it through the name checks...
cachedItem = getTypeOrModuleName(cachedItem);
// Add it to the namesCache...
env.namesCache.put(item,cachedItem);
}
result[index--] = cachedItem;
current = current.getQualifier();
}
}
// If it is supposed to be "boxed", prepend
// IDL_BOXEDIDL_MODULE...
if (boxIt) {
if (result == null) {
result = IDL_BOXEDIDL_MODULE;
} else {
String[] boxed = new String[result.length+IDL_BOXEDIDL_MODULE.length];
System.arraycopy(IDL_BOXEDIDL_MODULE,0,boxed,0,IDL_BOXEDIDL_MODULE.length);
System.arraycopy(result,0,boxed,IDL_BOXEDIDL_MODULE.length,result.length);
result = boxed;
}
}
return result;
}
/**
* Get an array name with the specified dimensions.
* <p>
* Section 28.3.6 (see ArrayType)
*/
public static String getArrayName (Type theType, int arrayDimension) {
StringBuffer idlName = new StringBuffer(64);
// Prefix with seq<n>_...
idlName.append(IDL_SEQUENCE);
idlName.append(Integer.toString(arrayDimension));
idlName.append("_");
// Add the type name. We need to map any spaces in the
// name to "_"...
idlName.append(replace(stripLeadingUnderscore(theType.getIDLName())," ","_"));
// And we're done...
return idlName.toString();
}
/**
* Get an array module names.
*/
public static String[] getArrayModuleNames (Type theType) {
String[] moduleName;
String[] typeModule = theType.getIDLModuleNames();
int typeModuleLength = typeModule.length;
// Does the type have a module?
if (typeModuleLength == 0) {
// Nope, so just use the sequence module...
moduleName = IDL_SEQUENCE_MODULE;
} else {
// Yes, so gotta concatenate...
moduleName = new String[typeModuleLength + IDL_SEQUENCE_MODULE.length];
System.arraycopy(IDL_SEQUENCE_MODULE,0,moduleName,0,IDL_SEQUENCE_MODULE.length);
System.arraycopy(typeModule,0,moduleName,IDL_SEQUENCE_MODULE.length,typeModuleLength);
}
return moduleName;
}
private static int getInitialAttributeKind (CompoundType.Method method,
BatchEnvironment env) throws ClassNotFound {
int result = ATTRIBUTE_NONE;
// First make sure it is not a constructor...
if (!method.isConstructor()) {
// Now check exceptions. It may not throw any checked
// exception other than RemoteException or one of its
// subclasses...
boolean validExceptions = true;
ClassType[] exceptions = method.getExceptions();
if (exceptions.length > 0) {
for (int i = 0; i < exceptions.length; i++) {
if (exceptions[i].isCheckedException() &&
!exceptions[i].isRemoteExceptionOrSubclass()) {
validExceptions = false;
break;
}
}
} else {
// If this is a ValueType, it is ok to not have any exceptions,
// otherwise this method does not qualify...
validExceptions = method.getEnclosing().isType(TYPE_VALUE);
}
if (validExceptions) {
String name = method.getName();
int nameLength = name.length();
int argCount = method.getArguments().length;
Type returnType = method.getReturnType();
boolean voidReturn = returnType.isType(TYPE_VOID);
boolean booleanReturn = returnType.isType(TYPE_BOOLEAN);
// It's a getter if name starts with "get" and it has no arguments
// and a return type that is not void...
if (name.startsWith("get") && nameLength > 3 && argCount == 0 && !voidReturn) {
result = ATTRIBUTE_GET;
} else {
// It's a getter if name starts with "is" and it has no arguments
// and a boolean return type...
if (name.startsWith("is") && nameLength > 2 && argCount == 0 && booleanReturn) {
result = ATTRIBUTE_IS;
} else {
// It's a setter if name starts with "set" and it has 1 argument
// and a void return type...
if (name.startsWith("set") && nameLength > 3 && argCount == 1 && voidReturn) {
result = ATTRIBUTE_SET;
}
}
}
}
}
return result;
}
private static void setAttributeKinds (CompoundType.Method[] methods,
int[] kinds,
String[] names) {
int count = methods.length;
// Strip the prefixes off of the attribute names...
for (int i = 0; i < count; i++) {
switch (kinds[i]) {
case ATTRIBUTE_GET: names[i] = names[i].substring(3); break;
case ATTRIBUTE_IS: names[i] = names[i].substring(2); break;
case ATTRIBUTE_SET: names[i] = names[i].substring(3); break;
}
}
// Now, we need to look at all the IS attributes to see
// if there is a corresponding getter or setter which has
// a different return type. If so, mark it as not an
// attribute. Do this before checking for invalid setters...
for (int i = 0; i < count; i++) {
if (kinds[i] == ATTRIBUTE_IS) {
for (int j = 0; j < count; j++) {
if (j != i &&
(kinds[j] == ATTRIBUTE_GET || kinds[j] == ATTRIBUTE_SET) &&
names[i].equals(names[j])) {
// We have matching getter or setter. Do the types match?
Type isType = methods[i].getReturnType();
Type targetType;
if (kinds[j] == ATTRIBUTE_GET) {
targetType = methods[j].getReturnType();
} else {
targetType = methods[j].getArguments()[0];
}
if (!isType.equals(targetType)) {
// No, so forget this guy as an attribute...
kinds[i] = ATTRIBUTE_NONE;
names[i] = methods[i].getName();
break;
}
}
}
}
}
// Now, we need to look at all the setters to see if there
// is a corresponding getter. If not, it is not a setter.
// If there is, change the getter type to _RW and set the
// pair index...
for (int i = 0; i < count; i++) {
if (kinds[i] == ATTRIBUTE_SET) {
int getterIndex = -1;
int isGetterIndex = -1;
// First look for is-getters, then for getters.
// This is preferred for boolean attributes.
for (int j = 0; j < count; j++) {
if (j != i && names[i].equals(names[j])) {
// Yep, is the return type of the getter the same
// as the argument type of the setter?
Type getterReturn = methods[j].getReturnType();
Type setterArg = methods[i].getArguments()[0];
if (getterReturn.equals(setterArg)) {
if (kinds[j] == ATTRIBUTE_IS) {
isGetterIndex = j;
// continue looking for another getter
} else if (kinds[j] == ATTRIBUTE_GET) {
getterIndex = j;
// continue looking for an is-getter
}
}
}
}
if (getterIndex > -1) {
if (isGetterIndex > -1) {
// We have both, a boolean is-getter and a boolean getter.
// Use the is-getter and drop the getter.
// We have a matching getter. Change it to a read-write type...
kinds[isGetterIndex] = ATTRIBUTE_IS_RW;
// Now set the pair index for both the getter and the setter...
methods[isGetterIndex].setAttributePairIndex(i);
methods[i].setAttributePairIndex(isGetterIndex);
// We found a better matching is-getter.
// Forget this other getter as an attribute.
kinds[getterIndex] = ATTRIBUTE_NONE;
names[getterIndex] = methods[getterIndex].getName();
} else {
// We only have one getter.
// We have a matching getter. Change it to a read-write type...
kinds[getterIndex] = ATTRIBUTE_GET_RW;
// Now set the pair index for both the getter and the setter...
methods[getterIndex].setAttributePairIndex(i);
methods[i].setAttributePairIndex(getterIndex);
}
} else {
if (isGetterIndex > -1) {
// We only have one is-getter.
// We have a matching getter. Change it to a read-write type...
kinds[isGetterIndex] = ATTRIBUTE_IS_RW;
// Now set the pair index for both the getter and the setter...
methods[isGetterIndex].setAttributePairIndex(i);
methods[i].setAttributePairIndex(isGetterIndex);
} else {
// We did not find a matching getter.
// Forget this setter as an attribute.
kinds[i] = ATTRIBUTE_NONE;
names[i] = methods[i].getName();
}
}
}
}
// Finally, do the case conversion and set the
// attribute kinds for each method...
for (int i = 0; i < count; i++) {
if (kinds[i] != ATTRIBUTE_NONE) {
String name = names[i];
// Is the first character upper case?
if (Character.isUpperCase(name.charAt(0))) {
// Yes, is the second?
if (name.length() == 1 || Character.isLowerCase(name.charAt(1))) {
// No, so convert the first character to lower case...
StringBuffer buffer = new StringBuffer(name);
buffer.setCharAt(0,Character.toLowerCase(name.charAt(0)));
names[i] = buffer.toString();
}
}
}
methods[i].setAttributeKind(kinds[i]);
}
}
/**
* Set all the method names in a given class.
* <p>
* Section 28.3.2.7 (see CompoundType)
* Section 28.3.2.7
* Section 28.3.4.3 (RemoteType/AbstractType only).
*/
public static void setMethodNames (CompoundType container,
CompoundType.Method[] allMethods,
BatchEnvironment env)
throws Exception {
// This method implements the following name mangling sequence:
//
// 1. If methods belong to a Remote interface, identify
// those which qualify as an attribute under 28.3.4.3.
// Those that do are referred to as 'attributes' below;
// those that do not are referred to as 'methods'.
//
// 2. Apply the 28.3.4.3 manglings, except "__", to all
// attribute names.
//
// 3. Apply all 28.3 manglings, except 28.3.2.7, to all names.
//
// 4. Apply 28.3.2.7 manglings to all method names.
//
// 5. Compare each attribute name to each method name. For
// any which compare equal, append "__" to the attribute
// name.
//
// 6. Compare each name (attribute and method) to all others.
// If any compare equal, throw an Exception with the
// conflicting name as the message.
int count = allMethods.length;
if (count == 0) return;
// Make an array of all the method names...
String[] names = new String[count];
for (int i = 0; i < count; i++) {
names[i] = allMethods[i].getName();
}
// Are we dealing with a RemoteType, AbstractType, or ValueType?
CompoundType enclosing = allMethods[0].getEnclosing();
if (enclosing.isType(TYPE_REMOTE) ||
enclosing.isType(TYPE_ABSTRACT) ||
enclosing.isType(TYPE_VALUE)) {
// Yes, so we must do the 28.3.4.3 attribute mapping. First, get
// the initial attribute kind of each method...
int[] kinds = new int[count];
for (int i = 0; i < count; i++) {
kinds[i] = getInitialAttributeKind(allMethods[i],env);
}
// Now set the attribute kind for each method and do the
// 28.3.4.3 name mangling...
setAttributeKinds(allMethods,kinds,names);
}
// Make and populate a new context from our names array...
NameContext context = new NameContext(true);
for (int i = 0; i < count; i++) {
context.put(names[i]);
}
// Apply the appropriate 28.3 manglings to all the names...
boolean haveConstructor = false;
for (int i = 0; i < count; i++) {
if (!allMethods[i].isConstructor()) {
names[i] = getMemberOrMethodName(context,names[i],env);
} else {
names[i] = IDL_CONSTRUCTOR;
haveConstructor = true;
}
}
// Now do the 28.3.2.7 mangling for method name collisions...
// Do this in two passes so that we don't change one during
// the detection of collisions and then miss a real one...
boolean overloaded[] = new boolean[count];
for (int i = 0; i < count; i++) {
overloaded[i] = (!allMethods[i].isAttribute() &&
!allMethods[i].isConstructor() &&
doesMethodCollide(names[i],allMethods[i],allMethods,names,true));
}
convertOverloadedMethods(allMethods,names,overloaded);
// Now do the same mangling for constructor name collisions...
for (int i = 0; i < count; i++) {
overloaded[i] = (!allMethods[i].isAttribute() &&
allMethods[i].isConstructor() &&
doesConstructorCollide(names[i],allMethods[i],allMethods,names,true));
}
convertOverloadedMethods(allMethods,names,overloaded);
// Now do the 28.3.4.3 mangling for attribute name collisions...
for (int i = 0; i < count; i++) {
CompoundType.Method method = allMethods[i];
// If this is an attribute name, does it collide with a method?
if (method.isAttribute() &&
doesMethodCollide(names[i],method,allMethods,names,true)) {
// Yes, so add double underscore...
names[i] += "__";
}
}
// Do the same mangling for any constructors which collide with
// methods...
if (haveConstructor) {
for (int i = 0; i < count; i++) {
CompoundType.Method method = allMethods[i];
// Is this a constructor which collides with a method?
if (method.isConstructor() &&
doesConstructorCollide(names[i],method,allMethods,names,false)) {
// Yes, so add double underscore...
names[i] += "__";
}
}
}
// Now see if we have a collision with the container name (28.3.2.9).
String containerName = container.getIDLName();
for (int i = 0; i < count; i++) {
if (names[i].equalsIgnoreCase(containerName)) {
// Do not add underscore to attributes.
// Otherwise getFoo will turn into _get_foo_.
if (! allMethods[i].isAttribute()) {
names[i] += "_";
}
}
}
// Now see if we have any collisions (28.3.2.9). If we do,
// it's an error. Note: a get/set pair does not collide.
for (int i = 0; i < count; i++) {
// Does it collide with any other name?
if (doesMethodCollide(names[i],allMethods[i],allMethods,names,false)) {
// Yes, so bail...
throw new Exception(allMethods[i].toString());
}
}
// Ok. We have unique names. Create the appropriate 'wire' name
// for each and set as the 'idl' name. If it is an attribute, also
// set the attribute name...
for (int i = 0; i < count; i++) {
CompoundType.Method method = allMethods[i];
String wireName = names[i];
if (method.isAttribute()) {
wireName = ATTRIBUTE_WIRE_PREFIX[method.getAttributeKind()] +
stripLeadingUnderscore(wireName);
String attributeName = names[i];
method.setAttributeName(attributeName);
}
method.setIDLName(wireName);
}
}
private static String stripLeadingUnderscore (String name) {
if (name != null && name.length() > 1
&& name.charAt(0) == '_')
{
return name.substring(1);
}
return name;
}
private static String stripTrailingUnderscore (String name) {
if (name != null && name.length() > 1 &&
name.charAt(name.length() - 1) == '_')
{
return name.substring(0, name.length() - 1);
}
return name;
}
private static void convertOverloadedMethods(CompoundType.Method[] allMethods,
String[] names,
boolean[] overloaded) {
for (int i = 0; i < names.length; i++) {
// Do we need to mangle it?
if (overloaded[i]) {
// Yes, so add arguments...
CompoundType.Method method = allMethods[i];
Type[] args = method.getArguments();
for (int k = 0; k < args.length; k++) {
// Add the separator...
names[i] += "__";
// Get the fully qualified IDL name, without the "::"
// prefix...
String argIDLName = args[k].getQualifiedIDLName(false);
// Replace any occurances of "::_" with "_" to
// undo any IDL keyword mangling and do next step
// at the same time...
argIDLName = replace(argIDLName,"::_","_");
// Replace any occurances of "::" with "_"...
argIDLName = replace(argIDLName,"::","_");
// Replace any occurances of " " with "_"...
argIDLName = replace(argIDLName," ","_");
// Add the argument type name...
names[i] += argIDLName;
}
if (args.length == 0) {
names[i] += "__";
}
// Remove any IDL keyword mangling...
names[i] = stripLeadingUnderscore(names[i]);
}
}
}
private static boolean doesMethodCollide (String name,
CompoundType.Method method,
CompoundType.Method[] allMethods,
String[] allNames,
boolean ignoreAttributes) {
// Scan all methods looking for a match...
for (int i = 0; i < allMethods.length; i++) {
CompoundType.Method target = allMethods[i];
if (method != target && // Not same instance
!target.isConstructor() && // Not a constructor
(!ignoreAttributes || !target.isAttribute()) && // Correct kind
name.equals(allNames[i])) { // Same names
// Are we looking at a get/set pair?
int kind1 = method.getAttributeKind();
int kind2 = target.getAttributeKind();
if ((kind1 != ATTRIBUTE_NONE && kind2 != ATTRIBUTE_NONE) &&
((kind1 == ATTRIBUTE_SET && kind2 != ATTRIBUTE_SET) ||
(kind1 != ATTRIBUTE_SET && kind2 == ATTRIBUTE_SET) ||
// one is a is-getter/setter pair and the other is just a getter
(kind1 == ATTRIBUTE_IS_RW && kind2 == ATTRIBUTE_GET) ||
(kind1 == ATTRIBUTE_GET && kind2 == ATTRIBUTE_IS_RW))) {
// Yes, so ignore it...
} else {
// No, so we have a collision...
return true;
}
}
}
return false;
}
private static boolean doesConstructorCollide (String name,
CompoundType.Method method,
CompoundType.Method[] allMethods,
String[] allNames,
boolean compareConstructors) {
// Scan all methods looking for a match...
for (int i = 0; i < allMethods.length; i++) {
CompoundType.Method target = allMethods[i];
if (method != target && // Not same instance
(target.isConstructor() == compareConstructors) && // Correct kind
name.equals(allNames[i])) { // Same names
// We have a collision...
return true;
}
}
return false;
}
/**
* Set all the member names in a given class.
* <p>
* Section 28.3.2.7 (see CompoundType)
* Section 28.3.2.7
*/
public static void setMemberNames (CompoundType container,
CompoundType.Member[] allMembers,
CompoundType.Method[] allMethods,
BatchEnvironment env)
throws Exception {
// Make and populate a new context...
NameContext context = new NameContext(true);
for (int i = 0; i < allMembers.length; i++) {
context.put(allMembers[i].getName());
}
// Now set all the idl names...
for (int i = 0; i < allMembers.length; i++) {
CompoundType.Member member = allMembers[i];
String idlName = getMemberOrMethodName(context,member.getName(),env);
member.setIDLName(idlName);
}
// First see if we have a collision with the container name (28.3.2.9).
String containerName = container.getIDLName();
for (int i = 0; i < allMembers.length; i++) {
String name = allMembers[i].getIDLName();
if (name.equalsIgnoreCase(containerName)) {
// REVISIT - How is this different than line 788
allMembers[i].setIDLName(name+"_");
}
}
// Check for collisions between member names...
for (int i = 0; i < allMembers.length; i++) {
String name = allMembers[i].getIDLName();
for (int j = 0; j < allMembers.length; j++) {
if (i != j && allMembers[j].getIDLName().equals(name)) {
// Collision...
throw new Exception(name);
}
}
}
// Now check for collisions between member names and
// method names...
boolean changed;
do {
changed = false;
for (int i = 0; i < allMembers.length; i++) {
String name = allMembers[i].getIDLName();
for (int j = 0; j < allMethods.length; j++) {
if (allMethods[j].getIDLName().equals(name)) {
// Collision, so append "_" to member name...
allMembers[i].setIDLName(name+"_");
changed = true;
break;
}
}
}
} while (changed);
}
/**
* Get the name for the specified type code.
* <p>
* Section 28.3..3 (see PrimitiveType)
* Section 28.3.5.10 (see SpecialClassType)
* Section 28.3.4.1 (see SpecialInterfaceType)
* Section 28.3.10.1 (see SpecialInterfaceType)
* Section 28.3.10.2 (see SpecialClassType)
*/
public static String getTypeName(int typeCode, boolean isConstant) {
String idlName = null;
switch (typeCode) {
case TYPE_VOID: idlName = IDL_VOID; break;
case TYPE_BOOLEAN: idlName = IDL_BOOLEAN; break;
case TYPE_BYTE: idlName = IDL_BYTE; break;
case TYPE_CHAR: idlName = IDL_CHAR; break;
case TYPE_SHORT: idlName = IDL_SHORT; break;
case TYPE_INT: idlName = IDL_INT; break;
case TYPE_LONG: idlName = IDL_LONG; break;
case TYPE_FLOAT: idlName = IDL_FLOAT; break;
case TYPE_DOUBLE: idlName = IDL_DOUBLE; break;
case TYPE_ANY: idlName = IDL_ANY; break;
case TYPE_CORBA_OBJECT: idlName = IDL_CORBA_OBJECT; break;
case TYPE_STRING:
{
if (isConstant) {
idlName = IDL_CONSTANT_STRING;
} else {
idlName = IDL_STRING;
}
break;
}
}
return idlName;
}
/**
* Create a qualified name.
*/
public static String getQualifiedName (String[] idlModuleNames, String idlName) {
String result = null;
if (idlModuleNames != null && idlModuleNames.length > 0) {
for (int i = 0; i < idlModuleNames.length;i++) {
if (i == 0) {
result = idlModuleNames[0];
} else {
result += IDL_NAME_SEPARATOR;
result += idlModuleNames[i];
}
}
result += IDL_NAME_SEPARATOR;
result += idlName;
} else {
result = idlName;
}
return result;
}
/**
* Replace substrings
* @param source The source string.
* @param match The string to search for within the source string.
* @param replace The replacement for any matching components.
* @return
*/
public static String replace (String source, String match, String replace) {
int index = source.indexOf(match,0);
if (index >=0) {
// We have at least one match, so gotta do the
// work...
StringBuffer result = new StringBuffer(source.length() + 16);
int matchLength = match.length();
int startIndex = 0;
while (index >= 0) {
result.append(source.substring(startIndex,index));
result.append(replace);
startIndex = index + matchLength;
index = source.indexOf(match,startIndex);
}
// Grab the last piece, if any...
if (startIndex < source.length()) {
result.append(source.substring(startIndex));
}
return result.toString();
} else {
// No matches, just return the source...
return source;
}
}
/**
* Get an IDL style repository id for
*/
public static String getIDLRepositoryID (String idlName) {
return IDL_REPOSITORY_ID_PREFIX +
replace(idlName,"::", "/") +
IDL_REPOSITORY_ID_VERSION;
}
//_____________________________________________________________________
// Internal Interfaces
//_____________________________________________________________________
/**
* Convert a type or module name.
* <p>
* Section 28.3.2.2
* Section 28.3.2.3
*/
private static String getTypeOrModuleName (String name) {
// 28.3.2.3 Leading underscores...
String result = convertLeadingUnderscores(name);
// 28.3.2.2 IDL keywords (NOTE: must be done
// after leading underscore conversion because
// the mangling for IDL keywords creates a
// leading underscore!)...
return convertIDLKeywords(result);
}
}