public MemberCodeGen(Bytecode b, CtClass cc, ClassPool cp) { super(b); resolver = new MemberResolver(cp); thisClass = cc; thisMethod = null; }
public Method lookupMethod(CtClass clazz, CtClass currentClass, MethodInfo current, String methodName, int[] argTypes, int[] argDims, String[] argClassNames) throws CompileError { Method maybe = null; // to enable the creation of a recursively called method if (current != null && clazz == currentClass) if (current.getName().equals(methodName)) { int res = compareSignature(current.getDescriptor(), argTypes, argDims, argClassNames); if (res != NO) { Method r = new Method(clazz, current, res); if (res == YES) return r; else maybe = r; } } Method m = lookupMethod(clazz, methodName, argTypes, argDims, argClassNames, maybe != null); if (m != null) return m; else return maybe; }
/** * Sets exprType, arrayDim, and className. * * @return true if the field type is long or double. */ private boolean setFieldType(FieldInfo finfo) throws CompileError { String type = finfo.getDescriptor(); int i = 0; int dim = 0; char c = type.charAt(i); while (c == '[') { ++dim; c = type.charAt(++i); } arrayDim = dim; exprType = MemberResolver.descToType(c); if (c == 'L') className = type.substring(i + 1, type.indexOf(';', i + 1)); else className = null; boolean is2byte = dim == 0 && (c == 'J' || c == 'D'); return is2byte; }
/** * @param jvmClassName a JVM class name. e.g. java/lang/String */ public CtField lookupFieldByJvmName(String jvmClassName, Symbol fieldName) throws CompileError { return lookupField(jvmToJavaName(jvmClassName), fieldName); }
public CtClass lookupClassByJvmName(String jvmName) throws CompileError { return lookupClass(jvmToJavaName(jvmName), false); }
/** * Returns the JVM-internal representation of this super class name. */ protected String getSuperName() throws CompileError { return MemberResolver.javaToJvmName( MemberResolver.getSuperclass(thisClass).getName()); }
targetClass = MemberResolver.getSuperclass(thisClass); else targetClass = thisClass; if (op == MEMBER) // static method targetClass = resolver.lookupClass(((Symbol)e.oprand1()).get(), false); else if (op == '.') { String classFollowedByDotSuper = isDotSuper(target); if (classFollowedByDotSuper != null) targetClass = MemberResolver.getSuperInterface(thisClass, classFollowedByDotSuper); else { e.setOprand1(new Symbol(MemberResolver.jvmToJavaName( className))); targetClass = resolver.lookupClass(javaLangObject, true); else if (exprType == CLASS /* && arrayDim == 0 */) targetClass = resolver.lookupClassByJvmName(className); else badMethod();
private CtField compileField(FieldDecl fd) throws CompileError, CannotCompileException { CtFieldWithInit f; Declarator d = fd.getDeclarator(); f = new CtFieldWithInit(gen.resolver.lookupClass(d), d.getVariable().get(), gen.getThisClass()); f.setModifiers(MemberResolver.getModifiers(fd.getModifiers())); if (fd.getInit() != null) f.setInit(fd.getInit()); return f; }
/** * @param classname jvm class name. */ public CtClass lookupClass(int type, int dim, String classname) throws CompileError { String cname = ""; CtClass clazz; if (type == CLASS) { clazz = lookupClassByJvmName(classname); if (dim > 0) cname = clazz.getName(); else return clazz; } else cname = getTypeName(type); while (dim-- > 0) cname += "[]"; return lookupClass(cname, false); }
protected static StringBuffer typeToString(StringBuffer sbuf, int type, int dim, String cname) { String s; if (type == CLASS) s = MemberResolver.jvmToJavaName(cname); else if (type == NULL) s = "Object"; else try { s = MemberResolver.getTypeName(type); } catch (CompileError e) { s = "?"; } sbuf.append(s); while (dim-- > 0) sbuf.append("[]"); return sbuf; }
/** * Only used by fieldAccess() in MemberCodeGen and TypeChecker. * * @param jvmClassName a JVM class name. e.g. java/lang/String * @see #lookupClass(String, boolean) */ public CtField lookupFieldByJvmName2(String jvmClassName, Symbol fieldSym, ASTree expr) throws NoFieldException { String field = fieldSym.get(); CtClass cc = null; try { cc = lookupClass(jvmToJavaName(jvmClassName), true); } catch (CompileError e) { // EXPR might be part of a qualified class name. throw new NoFieldException(jvmClassName + "/" + field, expr); } try { return cc.getField(field); } catch (NotFoundException e) { // maybe an inner class. jvmClassName = javaToJvmName(cc.getName()); throw new NoFieldException(jvmClassName + "$" + field, expr); } }
public String resolveClassName(ASTList name) throws CompileError { if (name == null) return null; else return javaToJvmName(lookupClassByName(name).getName()); }
public static int descToType(char c) throws CompileError { switch (c) { case 'Z' : return BOOLEAN; case 'C' : return CHAR; case 'B' : return BYTE; case 'S' : return SHORT; case 'I' : return INT; case 'J' : return LONG; case 'F' : return FLOAT; case 'D' : return DOUBLE; case 'V' : return VOID; case 'L' : case '[' : return CLASS; default : fatal(); return VOID; // never reach here } }
private CtField fieldAccess2(Expr e, String jvmClassName) throws CompileError { Member fname = (Member)e.oprand2(); CtField f = resolver.lookupFieldByJvmName2(jvmClassName, fname, e); e.setOperator(MEMBER); e.setOprand1(new Symbol(MemberResolver.jvmToJavaName(jvmClassName))); fname.setField(f); return f; }
private void setType(CtClass type, int dim) throws CompileError { if (type.isPrimitive()) { CtPrimitiveType pt = (CtPrimitiveType)type; exprType = MemberResolver.descToType(pt.getDescriptor()); arrayDim = dim; className = null; } else if (type.isArray()) try { setType(type.getComponentType(), dim + 1); } catch (NotFoundException e) { throw new CompileError("undefined type: " + type.getName()); } else { exprType = CLASS; arrayDim = dim; className = MemberResolver.javaToJvmName(type.getName()); } }
public String resolveJvmClassName(String jvmName) throws CompileError { if (jvmName == null) return null; else return javaToJvmName(lookupClassByJvmName(jvmName).getName()); }
protected void atCflow(ASTList cname) throws CompileError { StringBuffer sbuf = new StringBuffer(); if (cname == null || cname.tail() != null) throw new CompileError("bad " + cflowName); makeCflowName(sbuf, cname.head()); String name = sbuf.toString(); Object[] names = resolver.getClassPool().lookupCflow(name); if (names == null) throw new CompileError("no such " + cflowName + ": " + name); bytecode.addGetstatic((String)names[0], (String)names[1], "Ljavassist/runtime/Cflow;"); bytecode.addInvokevirtual("javassist.runtime.Cflow", "value", "()I"); exprType = INT; arrayDim = 0; className = null; }
name2 = MemberResolver.jvmToJavaName(name2); StringBuffer sbuf = new StringBuffer(); while (i-- >= 0) cname = resolveClassName(MemberResolver.javaToJvmName(cname)); cname = MemberResolver.jvmToJavaName(cname);
/** * Returns the JVM-internal representation of this class name. */ protected String getThisName() { return MemberResolver.javaToJvmName(thisClass.getName()); }
protected void insertDefaultSuperCall() throws CompileError { bytecode.addAload(0); bytecode.addInvokespecial(MemberResolver.getSuperclass(thisClass), "<init>", "()V"); }