/*

 * 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...