duke@1: /*
duke@1:  * Copyright 2002-2005 Sun Microsystems, Inc.  All Rights Reserved.
duke@1:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@1:  *
duke@1:  * This code is free software; you can redistribute it and/or modify it
duke@1:  * under the terms of the GNU General Public License version 2 only, as
duke@1:  * published by the Free Software Foundation.  Sun designates this
duke@1:  * particular file as subject to the "Classpath" exception as provided
duke@1:  * by Sun in the LICENSE file that accompanied this code.
duke@1:  *
duke@1:  * This code is distributed in the hope that it will be useful, but WITHOUT
duke@1:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@1:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
duke@1:  * version 2 for more details (a copy is included in the LICENSE file that
duke@1:  * accompanied this code).
duke@1:  *
duke@1:  * You should have received a copy of the GNU General Public License version
duke@1:  * 2 along with this work; if not, write to the Free Software Foundation,
duke@1:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@1:  *
duke@1:  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@1:  * CA 95054 USA or visit www.sun.com if you need additional information or
duke@1:  * have any questions.
duke@1:  */
duke@1: 
duke@1: 
duke@1: package com.sun.tools.javah;
duke@1: 
duke@1: import java.io.File;
duke@1: import java.io.OutputStream;
duke@1: import java.io.PrintWriter;
duke@1: import java.util.Hashtable;
duke@1: import com.sun.javadoc.*;
duke@1: 
duke@1:  /*
duke@1:   * @author  Sucheta Dambalkar(Revised)
duke@1:   */
duke@1: public class LLNI extends Gen {
duke@1: 
duke@1:     protected final char  pathChar = File.separatorChar;
duke@1:     protected final char  innerDelim = '$';     /* For inner classes */
duke@1:     protected Hashtable   doneHandleTypes;
duke@1:     MemberDoc []fields;
duke@1:     MemberDoc [] methods;
duke@1:     private boolean       doubleAlign;
duke@1:     private int           padFieldNum = 0;
duke@1: 
duke@1: 
duke@1:     LLNI(boolean doubleAlign, RootDoc root) {
duke@1:         super(root);
duke@1:         this.doubleAlign = doubleAlign;
duke@1:     }
duke@1: 
duke@1: 
duke@1:     protected String getIncludes() {
duke@1:         return "";
duke@1:     }
duke@1: 
duke@1:     protected void write(OutputStream o, ClassDoc clazz)
duke@1:         throws ClassNotFoundException {
duke@1:         String cname     = mangleClassName(clazz.qualifiedName());
duke@1:         PrintWriter pw   = wrapWriter(o);
duke@1:         fields = clazz.fields();
duke@1:         methods = clazz.methods();
duke@1:         generateDeclsForClass(pw, clazz, cname);
duke@1:     }
duke@1: 
duke@1:     protected void generateDeclsForClass(PrintWriter pw,
duke@1:                                          ClassDoc clazz, String cname)
duke@1:         throws ClassNotFoundException {
duke@1:         doneHandleTypes  = new Hashtable();
duke@1:         /* The following handle types are predefined in "typedefs.h". Suppress
duke@1:            inclusion in the output by generating them "into the blue" here. */
duke@1:         genHandleType(null, "java.lang.Class");
duke@1:         genHandleType(null, "java.lang.ClassLoader");
duke@1:         genHandleType(null, "java.lang.Object");
duke@1:         genHandleType(null, "java.lang.String");
duke@1:         genHandleType(null, "java.lang.Thread");
duke@1:         genHandleType(null, "java.lang.ThreadGroup");
duke@1:         genHandleType(null, "java.lang.Throwable");
duke@1: 
duke@1:         pw.println("/* LLNI Header for class " + clazz.qualifiedName() + " */" + lineSep);
duke@1:         pw.println("#ifndef _Included_" + cname);
duke@1:         pw.println("#define _Included_" + cname);
duke@1:         pw.println("#include \"typedefs.h\"");
duke@1:         pw.println("#include \"llni.h\"");
duke@1:         pw.println("#include \"jni.h\"" + lineSep);
duke@1: 
duke@1:         forwardDecls(pw, clazz);
duke@1:         structSectionForClass(pw, clazz, cname);
duke@1:         methodSectionForClass(pw, clazz, cname);
duke@1:         pw.println("#endif");
duke@1:     }
duke@1: 
duke@1:     protected void genHandleType(PrintWriter pw, String clazzname) {
duke@1:         String cname = mangleClassName(clazzname);
duke@1:         if (!doneHandleTypes.containsKey(cname)) {
duke@1:             doneHandleTypes.put(cname, cname);
duke@1:             if (pw != null) {
duke@1:                 pw.println("#ifndef DEFINED_" + cname);
duke@1:                 pw.println("    #define DEFINED_" + cname);
duke@1:                 pw.println("    GEN_HANDLE_TYPES(" + cname + ");");
duke@1:                 pw.println("#endif" + lineSep);
duke@1:             }
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     protected String mangleClassName(String s) {
duke@1:         return s.replace('.', '_')
duke@1:             .replace(pathChar, '_')
duke@1:             .replace(innerDelim, '_');
duke@1:     }
duke@1: 
duke@1:     protected void forwardDecls(PrintWriter pw, ClassDoc clazz)
duke@1:         throws ClassNotFoundException {
duke@1:         ClassDoc clazzfield = null;
duke@1: 
duke@1:         if (clazz.qualifiedName().equals("java.lang.Object"))
duke@1:             return;
duke@1:         genHandleType(pw, clazz.qualifiedName());
duke@1:         ClassDoc superClass = clazz.superclass();
duke@1: 
duke@1:         if(superClass != null){
duke@1:             String superClassName = superClass.qualifiedName();
duke@1:             forwardDecls(pw, superClass);
duke@1:         }
duke@1: 
duke@1:         for (int i = 0; i < fields.length; i++) {
duke@1:             FieldDoc field = (FieldDoc)fields[i];
duke@1: 
duke@1:             if (!field.isStatic()) {
duke@1:                 Type t = field.type();
duke@1:                 String tname = t.qualifiedTypeName();
duke@1:                 TypeSignature newTypeSig = new TypeSignature(root);
duke@1:                 String sig = newTypeSig.getTypeSignature(tname);
duke@1: 
duke@1:                 if (sig.charAt(0) != '[')
duke@1:                     forwardDeclsFromSig(pw, sig);
duke@1:             }
duke@1:         }
duke@1: 
duke@1:         for (int i = 0; i < methods.length; i++) {
duke@1:             MethodDoc method = (MethodDoc)methods[i];
duke@1: 
duke@1:             if (method.isNative()) {
duke@1:                 Type retType = method.returnType();
duke@1:                 String typesig = method.signature();
duke@1:                 TypeSignature newTypeSig = new TypeSignature(root);
duke@1:                 String sig = newTypeSig.getTypeSignature(typesig, retType);
duke@1: 
duke@1:                 if (sig.charAt(0) != '[')
duke@1:                     forwardDeclsFromSig(pw, sig);
duke@1: 
duke@1:             }
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     protected void forwardDeclsFromSig(PrintWriter pw, String sig) {
duke@1:         int    len = sig.length();
duke@1:         int    i   = sig.charAt(0) == '(' ? 1 : 0;
duke@1: 
duke@1:         /* Skip the initial "(". */
duke@1:         while (i < len) {
duke@1:             if (sig.charAt(i) == 'L') {
duke@1:                 int j = i + 1;
duke@1:                 while (sig.charAt(j) != ';') j++;
duke@1:                 genHandleType(pw, sig.substring(i + 1, j));
duke@1:                 i = j + 1;
duke@1:             } else {
duke@1:                 i++;
duke@1:             }
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     protected void structSectionForClass(PrintWriter pw,
duke@1:                                          ClassDoc jclazz, String cname)
duke@1:         throws ClassNotFoundException {
duke@1: 
duke@1:         String jname = jclazz.qualifiedName();
duke@1: 
duke@1:         if (cname.equals("java_lang_Object")) {
duke@1:             pw.println("/* struct java_lang_Object is defined in typedefs.h. */");
duke@1:             pw.println();
duke@1:             return;
duke@1:         }
duke@1:         pw.println("#if !defined(__i386)");
duke@1:         pw.println("#pragma pack(4)");
duke@1:         pw.println("#endif");
duke@1:         pw.println();
duke@1:         pw.println("struct " + cname + " {");
duke@1:         pw.println("    ObjHeader h;");
duke@1:         pw.print(fieldDefs(jclazz, cname));
duke@1: 
duke@1:         if (jname.equals("java.lang.Class"))
duke@1:             pw.println("    Class *LLNI_mask(cClass);" +
duke@1:                        "  /* Fake field; don't access (see oobj.h) */");
duke@1:         pw.println("};" + lineSep + lineSep + "#pragma pack()");
duke@1:         pw.println();
duke@1:         return;
duke@1:     }
duke@1: 
duke@1:     private static class FieldDefsRes {
duke@1:         public String className;        /* Name of the current class. */
duke@1:         public FieldDefsRes parent;
duke@1:         public String s;
duke@1:         public int byteSize;
duke@1:         public boolean bottomMost;
duke@1:         public boolean printedOne = false;
duke@1: 
duke@1:         FieldDefsRes(ClassDoc clazz, FieldDefsRes parent, boolean bottomMost) {
duke@1:             this.className = clazz.qualifiedName();
duke@1:             this.parent = parent;
duke@1:             this.bottomMost = bottomMost;
duke@1:             int byteSize = 0;
duke@1:             if (parent == null) this.s = "";
duke@1:             else this.s = parent.s;
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     /* Returns "true" iff added a field. */
duke@1:     private boolean doField(FieldDefsRes res, FieldDoc field,
duke@1:                             String cname, boolean padWord)
duke@1:         throws ClassNotFoundException {
duke@1: 
duke@1:         String fieldDef = addStructMember(field, cname, padWord);
duke@1:         if (fieldDef != null) {
duke@1:             if (!res.printedOne) { /* add separator */
duke@1:                 if (res.bottomMost) {
duke@1:                     if (res.s.length() != 0)
duke@1:                         res.s = res.s + "    /* local members: */" + lineSep;
duke@1:                 } else {
duke@1:                     res.s = res.s + "    /* inherited members from " +
duke@1:                         res.className + ": */" + lineSep;
duke@1:                 }
duke@1:                 res.printedOne = true;
duke@1:             }
duke@1:             res.s = res.s + fieldDef;
duke@1:             return true;
duke@1:         }
duke@1: 
duke@1:         // Otherwise.
duke@1:         return false;
duke@1:     }
duke@1: 
duke@1:     private int doTwoWordFields(FieldDefsRes res, ClassDoc clazz,
duke@1:                                 int offset, String cname, boolean padWord)
duke@1:         throws ClassNotFoundException {
duke@1:         boolean first = true;
duke@1:         FieldDoc[] fields = clazz.fields();
duke@1: 
duke@1:         for (int i = 0; i <fields.length; i++) {
duke@1:             FieldDoc field = fields[i];
duke@1:             String tc =field.type().typeName();
duke@1:             boolean twoWords = (tc.equals("long") || tc.equals("double"));
duke@1:             if (twoWords && doField(res, field, cname, first && padWord)) {
duke@1:                 offset += 8; first = false;
duke@1:             }
duke@1:         }
duke@1:         return offset;
duke@1:     }
duke@1: 
duke@1:     protected String fieldDefs(ClassDoc clazz, String cname)
duke@1:         throws ClassNotFoundException {
duke@1:         FieldDefsRes res = fieldDefs(clazz, cname, true);
duke@1:         return res.s;
duke@1:     }
duke@1: 
duke@1:     protected FieldDefsRes fieldDefs(ClassDoc clazz, String cname,
duke@1:                                      boolean bottomMost)
duke@1:         throws ClassNotFoundException {
duke@1:         FieldDefsRes res;
duke@1:         int offset;
duke@1:         boolean didTwoWordFields = false;
duke@1:         ClassDoc superclazz = clazz.superclass();
duke@1: 
duke@1:         if (superclazz != null) {
duke@1:             String supername = superclazz.qualifiedName();
duke@1:             res = new FieldDefsRes(clazz,
duke@1:                                    fieldDefs(superclazz, cname, false),
duke@1:                                    bottomMost);
duke@1:             offset = res.parent.byteSize;
duke@1:         } else {
duke@1:             res = new FieldDefsRes(clazz, null, bottomMost);
duke@1:             offset = 0;
duke@1:         }
duke@1: 
duke@1:         FieldDoc[] fields = clazz.fields();
duke@1: 
duke@1:         for (int i = 0; i < fields.length; i++) {
duke@1:             FieldDoc field = fields[i];
duke@1: 
duke@1:             if (doubleAlign && !didTwoWordFields && (offset % 8) == 0) {
duke@1:                 offset = doTwoWordFields(res, clazz, offset, cname, false);
duke@1:                 didTwoWordFields = true;
duke@1:             }
duke@1: 
duke@1:             String tc = field.type().typeName();
duke@1:             boolean twoWords = (tc.equals("long") ||tc.equals("double"));
duke@1: 
duke@1:             if (!doubleAlign || !twoWords) {
duke@1:                 if (doField(res, field, cname, false)) offset += 4;
duke@1:             }
duke@1: 
duke@1:         }
duke@1: 
duke@1:         if (doubleAlign && !didTwoWordFields) {
duke@1:             if ((offset % 8) != 0) offset += 4;
duke@1:             offset = doTwoWordFields(res, clazz, offset, cname, true);
duke@1:         }
duke@1: 
duke@1:         res.byteSize = offset;
duke@1:         return res;
duke@1:     }
duke@1: 
duke@1:     /* OVERRIDE: This method handles instance fields */
duke@1:     protected String addStructMember(FieldDoc member, String cname,
duke@1:                                      boolean padWord)
duke@1:         throws ClassNotFoundException {
duke@1:         String res = null;
duke@1: 
duke@1:         if (member.isStatic()) {
duke@1:             res = addStaticStructMember(member, cname);
duke@1:             //   if (res == null) /* JNI didn't handle it, print comment. */
duke@1:             //  res = "    /* Inaccessible static: " + member + " */" + lineSep;
duke@1:         } else {
duke@1:             if (padWord) res = "    java_int padWord" + padFieldNum++ + ";" + lineSep;
duke@1:             res = "    " + llniType(member.type(), false, false) + " " + llniFieldName(member);
duke@1:             if (isLongOrDouble(member.type())) res = res + "[2]";
duke@1:             res = res + ";" + lineSep;
duke@1:         }
duke@1:         return res;
duke@1:     }
duke@1: 
duke@1:     static private final boolean isWindows =
duke@1:         System.getProperty("os.name").startsWith("Windows");
duke@1: 
duke@1:     /*
duke@1:      * This method only handles static final fields.
duke@1:      */
duke@1:     protected String addStaticStructMember(FieldDoc field, String cname)
duke@1:         throws ClassNotFoundException {
duke@1:         String res = null;
duke@1:         Object exp = null;
duke@1: 
duke@1:         if (!field.isStatic())
duke@1:             return res;
duke@1:         if (!field.isFinal())
duke@1:             return res;
duke@1: 
duke@1:         exp = field.constantValue();
duke@1: 
duke@1:         if (exp != null) {
duke@1:             /* Constant. */
duke@1: 
duke@1:             String     cn     = cname + "_" + field.name();
duke@1:             String     suffix = null;
duke@1:             long           val = 0;
duke@1:             /* Can only handle int, long, float, and double fields. */
duke@1:             if (exp instanceof Integer) {
duke@1:                 suffix = "L";
duke@1:                 val = ((Integer)exp).intValue();
duke@1:             }
duke@1:             if (exp instanceof Long) {
duke@1:                 // Visual C++ supports the i64 suffix, not LL
duke@1:                 suffix = isWindows ? "i64" : "LL";
duke@1:                 val = ((Long)exp).longValue();
duke@1:             }
duke@1:             if (exp instanceof Float)  suffix = "f";
duke@1:             if (exp instanceof Double) suffix = "";
duke@1:             if (suffix != null) {
duke@1:                 // Some compilers will generate a spurious warning
duke@1:                 // for the integer constants for Integer.MIN_VALUE
duke@1:                 // and Long.MIN_VALUE so we handle them specially.
duke@1:                 if ((suffix.equals("L") && (val == Integer.MIN_VALUE)) ||
duke@1:                     (suffix.equals("LL") && (val == Long.MIN_VALUE))) {
duke@1:                     res = "    #undef  " + cn + lineSep
duke@1:                         + "    #define " + cn
duke@1:                         + " (" + (val + 1) + suffix + "-1)" + lineSep;
duke@1:                 } else {
duke@1:                     res = "    #undef  " + cn + lineSep
duke@1:                         + "    #define " + cn + " "+ exp.toString() + suffix + lineSep;
duke@1:                 }
duke@1:             }
duke@1:         }
duke@1:         return res;
duke@1:     }
duke@1: 
duke@1:     protected void methodSectionForClass(PrintWriter pw,
duke@1:                                          ClassDoc clazz, String cname)
duke@1:         throws ClassNotFoundException {
duke@1:         String methods = methodDecls(clazz, cname);
duke@1: 
duke@1:         if (methods.length() != 0) {
duke@1:             pw.println("/* Native method declarations: */" + lineSep);
duke@1:             pw.println("#ifdef __cplusplus");
duke@1:             pw.println("extern \"C\" {");
duke@1:             pw.println("#endif" + lineSep);
duke@1:             pw.println(methods);
duke@1:             pw.println("#ifdef __cplusplus");
duke@1:             pw.println("}");
duke@1:             pw.println("#endif");
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     protected String methodDecls(ClassDoc clazz, String cname)
duke@1:         throws ClassNotFoundException {
duke@1: 
duke@1:         String res = "";
duke@1:         for (int i = 0; i < methods.length; i++) {
duke@1:             MethodDoc method = (MethodDoc)methods[i];
duke@1:             if (method.isNative())
duke@1:                 res = res + methodDecl(method, clazz, cname);
duke@1:         }
duke@1:         return res;
duke@1:     }
duke@1: 
duke@1:     protected String methodDecl(MethodDoc method,
duke@1:                                 ClassDoc clazz, String cname)
duke@1:         throws ClassNotFoundException {
duke@1:         String res = null;
duke@1: 
duke@1:         Type retType = method.returnType();
duke@1:         String typesig = method.signature();
duke@1:         TypeSignature newTypeSig = new TypeSignature(root);
duke@1:         String sig = newTypeSig.getTypeSignature(typesig, retType);
duke@1:         boolean longName = needLongName(method, clazz);
duke@1: 
duke@1:         if (sig.charAt(0) != '(')
duke@1:             Util.error("invalid.method.signature", sig);
duke@1: 
duke@1: 
duke@1:         res = "JNIEXPORT " + jniType(retType) + " JNICALL" + lineSep + jniMethodName(method, cname, longName)
duke@1:             + "(JNIEnv *, " + cRcvrDecl(method, cname);
duke@1:         Parameter[] params = method.parameters();
duke@1:         Type argTypes[] = new Type[params.length];
duke@1:         for(int p = 0; p <  params.length; p++){
duke@1:             argTypes[p] =  params[p].type();
duke@1:         }
duke@1: 
duke@1:         /* It would have been nice to include the argument names in the
duke@1:            declaration, but there seems to be a bug in the "BinaryField"
duke@1:            class, causing the getArguments() method to return "null" for
duke@1:            most (non-constructor) methods. */
duke@1:         for (int i = 0; i < argTypes.length; i++)
duke@1:             res = res + ", " + jniType(argTypes[i]);
duke@1:         res = res + ");" + lineSep;
duke@1:         return res;
duke@1:     }
duke@1: 
duke@1:     protected final boolean needLongName(MethodDoc method,
duke@1:                                          ClassDoc clazz)
duke@1:         throws ClassNotFoundException {
duke@1:         String methodName = method.name();
duke@1:         for (int i = 0; i < methods.length; i++) {
duke@1:             MethodDoc memberMethod = (MethodDoc) methods[i];
duke@1:             if ((memberMethod != method) &&
duke@1:                 memberMethod.isNative() && (methodName == memberMethod.name()))
duke@1:                 return true;
duke@1:         }
duke@1:         return false;
duke@1:     }
duke@1: 
duke@1:     protected final String jniMethodName(MethodDoc method, String cname,
duke@1:                                          boolean longName) {
duke@1:         String res = "Java_" + cname + "_" + method.name();
duke@1: 
duke@1:         if (longName) {
duke@1:             Type mType =  method.returnType();
duke@1:             Parameter[] params = method.parameters();
duke@1:             Type argTypes[] = new Type[params.length];
duke@1:             for(int p = 0; p <  params.length; p++){
duke@1:                 argTypes[p] =  params[p].type();
duke@1:             }
duke@1: 
duke@1:             res = res + "__";
duke@1:             for (int i = 0; i < argTypes.length; i++){
duke@1:                 Type t = argTypes[i];
duke@1:                 String tname = t.typeName();
duke@1:                 TypeSignature newTypeSig = new TypeSignature(root);
duke@1:                 String sig = newTypeSig.getTypeSignature(tname);
duke@1:                 res = res + nameToIdentifier(sig);
duke@1:             }
duke@1:         }
duke@1:         return res;
duke@1:     }
duke@1: 
duke@1:     protected final String jniType(Type t) {
duke@1:         String elmT =t.typeName();
duke@1:         if (t.dimension().indexOf("[]") != -1) {
duke@1:             if(elmT.equals("boolean"))return "jbooleanArray";
duke@1:             else if(elmT.equals("byte"))return "jbyteArray";
duke@1:             else if(elmT.equals("char"))return "jcharArray";
duke@1:             else if(elmT.equals("short"))return "jshortArray";
duke@1:             else if(elmT.equals("int"))return "jintArray";
duke@1:             else if(elmT.equals("long"))return "jlongArray";
duke@1:             else if(elmT.equals("float"))return "jfloatArray";
duke@1:             else if(elmT.equals("double"))return "jdoubleArray";
duke@1:             else if((t.dimension().indexOf("[][]") != -1) || (t.asClassDoc() != null))  return "jobjectArray";
duke@1:         } else {
duke@1:             if(elmT.equals("void"))return "void";
duke@1:             else if(elmT.equals("boolean"))return "jboolean";
duke@1:             else if(elmT.equals("byte"))return "jbyte";
duke@1:             else if(elmT.equals("char"))return "jchar";
duke@1:             else if(elmT.equals("short"))return "jshort";
duke@1:             else if(elmT.equals("int"))return "jint";
duke@1:             else if(elmT.equals("long"))return "jlong";
duke@1:             else if(elmT.equals("float"))return "jfloat";
duke@1:             else if(elmT.equals("double"))return "jdouble";
duke@1:             else if (t.asClassDoc() != null) {
duke@1:                 if (elmT.equals("String"))
duke@1:                     return "jstring";
duke@1:                 else if (t.asClassDoc().subclassOf(root.classNamed("java.lang.Class")))
duke@1:                     return "jclass";
duke@1:                 else
duke@1:                     return "jobject";
duke@1:             }
duke@1:         }
duke@1:         Util.bug("jni.unknown.type");
duke@1:         return null; /* dead code. */
duke@1:     }
duke@1: 
duke@1:     protected String llniType(Type t, boolean handleize, boolean longDoubleOK) {
duke@1:         String res = null;
duke@1:         String elmt = t.typeName();
duke@1:         if (t.dimension().indexOf("[]") != -1) {
duke@1:             if((t.dimension().indexOf("[][]") != -1)
duke@1:                || (t.asClassDoc() != null)) res = "IArrayOfRef";
duke@1:             else if(elmt.equals("boolean")) res =  "IArrayOfBoolean";
duke@1:             else if(elmt.equals("byte")) res =  "IArrayOfByte";
duke@1:             else if(elmt.equals("char")) res =  "IArrayOfChar";
duke@1:             else if(elmt.equals("int")) res =  "IArrayOfInt";
duke@1:             else if(elmt.equals("long")) res =  "IArrayOfLong";
duke@1:             else if(elmt.equals("float")) res =  "IArrayOfFloat";
duke@1:             else if(elmt.equals("double")) res =  "IArrayOfDouble";
duke@1:             if (!handleize) res = "DEREFERENCED_" + res;
duke@1:         } else {
duke@1:             if(elmt.equals("void")) res =  "void";
duke@1:             else if( (elmt.equals("boolean")) || (elmt.equals("byte"))
duke@1:                      ||(elmt.equals("char")) || (elmt.equals("short"))
duke@1:                      || (elmt.equals("int")))   res = "java_int";
duke@1:             else   if(elmt.equals("long")) res = longDoubleOK
duke@1:                                                ? "java_long" : "val32 /* java_long */";
duke@1:             else   if(elmt.equals("float")) res =  "java_float";
duke@1:             else   if(elmt.equals("double")) res =  res = longDoubleOK
duke@1:                                                  ? "java_double" : "val32 /* java_double */";
duke@1:             else if(t.asClassDoc() != null) {
duke@1:                 res = "I" +  mangleClassName(t.asClassDoc().qualifiedName());
duke@1:                 if (!handleize) res = "DEREFERENCED_" + res;
duke@1:             }
duke@1:         }
duke@1:         return res;
duke@1:     }
duke@1: 
duke@1:     protected final String cRcvrDecl(MemberDoc field, String cname) {
duke@1:         return (field.isStatic() ? "jclass" : "jobject");
duke@1:     }
duke@1: 
duke@1:     protected String maskName(String s) {
duke@1:         return "LLNI_mask(" + s + ")";
duke@1:     }
duke@1: 
duke@1:     protected String llniFieldName(MemberDoc field) {
duke@1:         return maskName(field.name());
duke@1:     }
duke@1: 
duke@1:     protected final boolean isLongOrDouble(Type t) {
duke@1:         String tc = t.typeName();
duke@1:         return (tc.equals("long") || tc.equals("double"));
duke@1:     }
duke@1: 
duke@1:     /* Do unicode to ansi C identifier conversion.
duke@1:        %%% This may not be right, but should be called more often. */
duke@1:     protected final String nameToIdentifier(String name) {
duke@1:         int len = name.length();
duke@1:         StringBuffer buf = new StringBuffer(len);
duke@1:         for (int i = 0; i < len; i++) {
duke@1:             char c = name.charAt(i);
duke@1:             if (isASCIILetterOrDigit(c))
duke@1:                 buf.append(c);
duke@1:             else if (c == '/')
duke@1:                 buf.append('_');
duke@1:             else if (c == '.')
duke@1:                 buf.append('_');
duke@1:             else if (c == '_')
duke@1:                 buf.append("_1");
duke@1:             else if (c == ';')
duke@1:                 buf.append("_2");
duke@1:             else if (c == '[')
duke@1:                 buf.append("_3");
duke@1:             else
duke@1:                 buf.append("_0" + ((int)c));
duke@1:         }
duke@1:         return new String(buf);
duke@1:     }
duke@1: 
duke@1:     protected final boolean isASCIILetterOrDigit(char c) {
duke@1:         if (((c >= 'A') && (c <= 'Z')) ||
duke@1:             ((c >= 'a') && (c <= 'z')) ||
duke@1:             ((c >= '0') && (c <= '9')))
duke@1:             return true;
duke@1:         else
duke@1:             return false;
duke@1:     }
duke@1: }