Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * CodegenUtils.java
   *
   * Created on January 31, 2007, 11:54 AM
   *
   * To change this template, choose Tools | Template Manager
   * and open the template in the editor.
   */
  
 package org.jruby.util;
 
 import  org.objectweb.asm.AnnotationVisitor;
 import  org.objectweb.asm.Type;
 
 import java.util.Map;

Author(s):
headius
 
 public class CodegenUtils {
    
Creates a dotted class name from a path/package name
 
     public static String c(String p) {
         return p.replace('/''.');
     }

    
Creates a class path name, from a Class.
 
     public static String p(Class n) {
         return n.getName().replace('.','/');
     }

    
Creates a class identifier of form Labc/abc;, from a Class.
 
     public static String ci(Class n) {
         if (n.isArray()) {
             n = n.getComponentType();
             if (n.isPrimitive()) {
                 if (n == .) {
                     return "[B";
                 } else if (n == .) {
                     return "[Z";
                 } else if (n == .) {
                     return "[S";
                 } else if (n == .) {
                     return "[C";
                 } else if (n == .) {
                     return "[I";
                 } else if (n == .) {
                     return "[F";
                 } else if (n == .) {
                     return "[D";
                 } else if (n == .) {
                     return "[J";
                 } else {
                     throw new RuntimeException("Unrecognized type in compiler: " + n.getName());
                 }
             } else {
                 return "[" + ci(n);
             }
         } else {
             if (n.isPrimitive()) {
                 if (n == .) {
                     return "B";
                 } else if (n == .) {
                     return "Z";
                 } else if (n == .) {
                     return "S";
                 } else if (n == .) {
                     return "C";
                 } else if (n == .) {
                     return "I";
                 } else if (n == .) {
                     return "F";
                 } else if (n == .) {
                     return "D";
                 } else if (n == .) {
                     return "J";
                 } else if (n == .) {
                     return "V";
                 } else {
                     throw new RuntimeException("Unrecognized type in compiler: " + n.getName());
                 }
             } else {
                 return "L" + p(n) + ";";
             }
         }
     }

    
Creates a human-readable representation, from a Class.
    public static String human(Class n) {
        return n.getCanonicalName();
    }
    
    public static String humanShort(Class n) {
        return n.getSimpleName();
    }
    
    
Create a method signature from the given param types and return values
    public static String sig(Class retvalClass... params) {
        return sigParams(params) + ci(retval);
    }
    
    public static String sig(Class[] retvalParams) {
        Class[] justParams = new Class[retvalParams.length - 1];
        System.arraycopy(retvalParams, 1, justParams, 0, justParams.length);
        return sigParams(justParams) + ci(retvalParams[0]);
    }
    public static String sig(Class retvalString descriptorClass... params) {
        return sigParams(descriptorparams) + ci(retval);
    }
    public static String sigParams(Class... params) {
        StringBuilder signature = new StringBuilder("(");
        
        for (int i = 0; i < params.lengthi++) {
            signature.append(ci(params[i]));
        }
        
        signature.append(")");
        
        return signature.toString();
    }
    public static String sigParams(String descriptorClass... params) {
        StringBuilder signature = new StringBuilder("(");
        signature.append(descriptor);
        
        for (int i = 0; i < params.lengthi++) {
            signature.append(ci(params[i]));
        }
        signature.append(")");
        return signature.toString();
    }
    
    public static String pretty(Class retvalClass... params) {
        return prettyParams(params) + human(retval);
    }
    
    public static String prettyParams(Class... params) {
        StringBuilder signature = new StringBuilder("(");
        
        for (int i = 0; i < params.lengthi++) {
            signature.append(human(params[i]));
            if (i < params.length - 1) signature.append(',');
        }
        
        signature.append(")");
        
        return signature.toString();
    }
    
    public static String prettyShortParams(Class... params) {
        StringBuilder signature = new StringBuilder("(");
        
        for (int i = 0; i < params.lengthi++) {
            signature.append(humanShort(params[i]));
            if (i < params.length - 1) signature.append(',');
        }
        
        signature.append(")");
        
        return signature.toString();
    }
    
    public static Class[] params(Class... classes) {
        return classes;
    }
    
    public static Class[] params(Class clsint times) {
        Class[] classes = new Class[times];
        Arrays.fill(classescls);
        return classes;
    }
    
    public static Class[] params(Class cls1Class clsFillint times) {
        Class[] classes = new Class[times + 1];
        Arrays.fill(classesclsFill);
        classes[0] = cls1;
        return classes;
    }
    public static Class[] params(Class cls1Class cls2Class clsFillint times) {
        Class[] classes = new Class[times + 2];
        Arrays.fill(classesclsFill);
        classes[0] = cls1;
        classes[1] = cls2;
        return classes;
    }
    public static Class[] params(Class cls1Class clsFillint timesClass clsTail) {
        Class[] classes = new Class[times + 2];
        Arrays.fill(classesclsFill);
        classes[0] = cls1;
        classes[times + 1] = clsTail;
        return classes;
    }
    
    public static String getAnnotatedBindingClassName(Name javaMethodNameCharSequence typeNameboolean isStaticint requiredint optionalboolean multiboolean framed) {
        return getAnnotatedBindingClassName(javaMethodName.toString(), typeNameisStaticrequiredoptionalmultiframed);
    }
    public static String getAnnotatedBindingClassName(String javaMethodNameCharSequence typeNameboolean isStaticint requiredint optionalboolean multiboolean framed) {
        String commonClassSuffix = "$INVOKER" + (isStatic ? "$s$" : "$i$" );
        if (multi) {
            commonClassSuffix += javaMethodName;
        } else {
            commonClassSuffix += required + "$" + optional + "$" + javaMethodName;
        }
        return typeName + commonClassSuffix;
    }
    public static void visitAnnotationFields(AnnotationVisitor visitorMap<StringObjectfields) {
        try {
            for (Map.Entry<StringObjectfieldEntry : fields.entrySet()) {
                Object value = fieldEntry.getValue();
                String key = fieldEntry.getKey();
                if (value instanceof Map) {
                    Map<ClassMap<StringObject>> nestedAnnotationMap = (Map<ClassMap<StringObject>>) value;
                    for (Map.Entry<ClassMap<StringObject>> nestedAnnotation : nestedAnnotationMap.entrySet()) {
                        AnnotationVisitor annotationV;
                        annotationV = visitor.visitAnnotation(key, Type.getType(nestedAnnotation.getKey()).getDescriptor());
                        visitAnnotationFields(annotationVnestedAnnotation.getValue());
                        annotationV.visitEnd();
                    }
                } else if (value.getClass().isArray()) {
                    Object[] values = (Object[]) value;
                    AnnotationVisitor arrayV = visitor.visitArray(key);
                    for (int i = 0; i < values.lengthi++) {
                        Map<StringObjectmap = new HashMap<StringObject>();
                        map.put(nullvalues[i]);
                        visitAnnotationFields(arrayVmap);
                    }
                    arrayV.visitEnd();
                } else if (value.getClass().isEnum()) {
                    visitor.visitEnum(keyci(value.getClass()), value.toString());
                } else if (value instanceof Class) {
                    visitor.visit(key, Type.getType((Classvalue));
                } else {
                    visitor.visit(keyvalue);
                }
            }
        } catch (ClassCastException e) {
            throw new InvalidAnnotationDescriptorException("Fields "
                + fields
                + " did not match annotation format.  See CodegenUtils#visitAnnotationFields for format",
                e);
        }
    }
    public static Class getBoxType(Class type) {
        if (type == int.class) {
            return Integer.class;
        } else if (type == byte.class) {
            return Byte.class;
        } else if (type == short.class) {
            return Short.class;
        } else if (type == char.class) {
            return Character.class;
        } else if (type == long.class) {
            return Long.class;
        } else if (type == float.class) {
            return Float.class;
        } else if (type == double.class) {
            return Double.class;
        } else if (type == boolean.class) {
            return Boolean.class;
        } else if (type == void.class) {
            return Void.class;
        } else {
            throw new RuntimeException("Not a native type: " + type);
        }
    }
    public static class InvalidAnnotationDescriptorException extends RuntimeException {
        public InvalidAnnotationDescriptorException() {
        }
        public InvalidAnnotationDescriptorException(String s) {
            super(s);
        }
        public InvalidAnnotationDescriptorException(String sThrowable throwable) {
            super(sthrowable);
        }
        public InvalidAnnotationDescriptorException(Throwable throwable) {
            super(throwable);
        }
    }
New to GrepCode? Check out our FAQ X