private void printField(PrintWriter out, FieldNode fieldNode, boolean isInterface) {
if ((fieldNode.getModifiers() & Opcodes.ACC_PRIVATE) != 0) return;
printAnnotations(out, fieldNode);
if (!isInterface) {
printModifiers(out, fieldNode.getModifiers());
}
ClassNode type = fieldNode.getType();
printType(out, type);
out.print(" ");
out.print(fieldNode.getName());
if (isInterface || (fieldNode.getModifiers() & Opcodes.ACC_FINAL) != 0) {
out.print(" = ");
Expression valueExpr = fieldNode.getInitialValueExpression();
if (valueExpr instanceof ConstantExpression) {
valueExpr = Verifier.transformToPrimitiveConstantIfPossible((ConstantExpression) valueExpr);
}
if (valueExpr instanceof ConstantExpression
&& fieldNode.isStatic()
&& fieldNode.isFinal()
&& ClassHelper.isStaticConstantInitializerType(valueExpr.getType())
&& valueExpr.getType().equals(fieldNode.getType())) {
// GROOVY-5150 : Initialize value with a dummy constant so that Java cross compiles
// correctly
if (ClassHelper.STRING_TYPE.equals(valueExpr.getType())) {
out.print("\"" + escapeSpecialChars(valueExpr.getText()) + "\"");
} else if (ClassHelper.char_TYPE.equals(valueExpr.getType())) {
out.print("'" + valueExpr.getText() + "'");
} else {
ClassNode constantType = valueExpr.getType();
out.print('(');
printType(out, type);
out.print(") ");
out.print(valueExpr.getText());
if (ClassHelper.Long_TYPE.equals(ClassHelper.getWrapper(constantType))) out.print('L');
}
} else if (ClassHelper.isPrimitiveType(type)) {
String val = type == ClassHelper.boolean_TYPE ? "false" : "0";
out.print("new " + ClassHelper.getWrapper(type) + "((" + type + ")" + val + ")");
} else {
out.print("null");
}
}
out.println(";");
}
/**
* Visits a class literal. If the type of the classnode is a primitive type, the generated
* bytecode will be a GETSTATIC Integer.TYPE. If the classnode is not a primitive type, we will
* generate a LDC instruction.
*/
public static void visitClassLiteral(MethodVisitor mv, ClassNode classNode) {
if (ClassHelper.isPrimitiveType(classNode)) {
mv.visitFieldInsn(
GETSTATIC,
getClassInternalName(ClassHelper.getWrapper(classNode)),
"TYPE",
"Ljava/lang/Class;");
} else {
mv.visitLdcInsn(org.objectweb.asm.Type.getType(getTypeDescription(classNode)));
}
}
public ClassNode box() {
MethodVisitor mv = controller.getMethodVisitor();
int size = stack.size();
ClassNode type = stack.get(size - 1);
if (ClassHelper.isPrimitiveType(type) && ClassHelper.VOID_TYPE != type) {
ClassNode wrapper = ClassHelper.getWrapper(type);
BytecodeHelper.doCastToWrappedType(mv, type, wrapper);
type = wrapper;
} // else nothing to box
stack.set(size - 1, type);
return type;
}
private void doConvertAndCast(ClassNode targetType, boolean coerce) {
int size = stack.size();
throwExceptionForNoStackElement(size, targetType, coerce);
ClassNode top = stack.get(size - 1);
targetType = targetType.redirect();
if (targetType == top) return;
if (coerce) {
controller.getInvocationWriter().coerce(top, targetType);
return;
}
boolean primTarget = ClassHelper.isPrimitiveType(targetType);
boolean primTop = ClassHelper.isPrimitiveType(top);
if (primTop && primTarget) {
// here we box and unbox to get the goal type
if (convertPrimitive(top, targetType)) {
replace(targetType);
return;
}
box();
} else if (primTop) {
// top is primitive, target is not
// so box and do groovy cast
controller.getInvocationWriter().castToNonPrimitiveIfNecessary(top, targetType);
} else if (primTarget) {
// top is not primitive so unbox
// leave that BH#doCast later
} else {
controller.getInvocationWriter().castToNonPrimitiveIfNecessary(top, targetType);
}
MethodVisitor mv = controller.getMethodVisitor();
if (primTarget
&& !ClassHelper.boolean_TYPE.equals(targetType)
&& !primTop
&& ClassHelper.getWrapper(targetType).equals(top)) {
BytecodeHelper.doCastToPrimitive(mv, top, targetType);
} else {
top = stack.get(size - 1);
if (!WideningCategories.implementsInterfaceOrSubclassOf(top, targetType)) {
BytecodeHelper.doCast(mv, targetType);
}
}
replace(targetType);
}
