--- old/src/share/classes/com/sun/tools/javac/util/Constants.java 2009-09-23 18:29:04.000000000 -0700 +++ new/src/share/classes/com/sun/tools/javac/util/Constants.java 2009-09-23 18:29:04.000000000 -0700 @@ -83,16 +83,28 @@ */ public static String format(Object value) { if (value instanceof Byte) return formatByte((Byte) value); + if (value instanceof Short) return formatShort((Short) value); if (value instanceof Long) return formatLong((Long) value); if (value instanceof Float) return formatFloat((Float) value); if (value instanceof Double) return formatDouble((Double) value); if (value instanceof Character) return formatChar((Character) value); if (value instanceof String) return formatString((String) value); - return value + ""; + if (value instanceof Integer || + value instanceof Boolean) return value.toString(); + else + throw new IllegalArgumentException("Argument is not a primitive type or a string; it " + + ((value == null) ? + "is a null value." : + "has class " + + value.getClass().getName()) + "." ); } private static String formatByte(byte b) { - return String.format("0x%02x", b); + return String.format("(byte)0x%02x", b); + } + + private static String formatShort(short s) { + return String.format("(short)%d", s); } private static String formatLong(long lng) { --- old/src/share/classes/com/sun/tools/javac/util/Convert.java 2009-09-23 18:29:05.000000000 -0700 +++ new/src/share/classes/com/sun/tools/javac/util/Convert.java 2009-09-23 18:29:04.000000000 -0700 @@ -239,9 +239,9 @@ case '\"': return "\\\""; case '\\': return "\\\\"; default: - return (ch > 127 || isPrintableAscii(ch)) + return (isPrintableAscii(ch)) ? String.valueOf(ch) - : String.format("\\%03o", (int) ch); + : String.format("\\u%04x", (int) ch); } } --- /dev/null 2009-08-12 17:12:33.000000000 -0700 +++ new/test/tools/javac/processing/model/util/elements/Foo.java 2009-09-23 18:29:05.000000000 -0700 @@ -0,0 +1,29 @@ + +/* + * Copyright 2009 Sun Microsystems, Inc. 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. + * + * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/** + * Dummy type to compile. + */ +public class Foo { +} \ No newline at end of file --- /dev/null 2009-08-12 17:12:33.000000000 -0700 +++ new/test/tools/javac/processing/model/util/elements/TestGetConstantExpression.java 2009-09-23 18:29:06.000000000 -0700 @@ -0,0 +1,143 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. 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. + * + * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 6471577 6517779 + * @summary Test Elements.getConstantExpression + * @author Joseph D. Darcy + * @build TestGetConstantExpression + * @compile -processor TestGetConstantExpression Foo.java + */ + +import java.util.Set; +import javax.annotation.processing.*; +import javax.lang.model.SourceVersion; +import static javax.lang.model.SourceVersion.*; +import javax.lang.model.element.*; +import javax.lang.model.util.*; +import static javax.lang.model.util.ElementFilter.*; +import static javax.tools.Diagnostic.Kind.*; +import static javax.tools.StandardLocation.*; +import java.io.*; + +/** + * Test basic workings of Elements.getConstantExpression. + */ +@SupportedAnnotationTypes("*") +public class TestGetConstantExpression extends AbstractProcessor { + private Elements eltUtils; + private Filer filer; + private int round = 1; + + /** + * Check expected behavior on classes and packages. + */ + public boolean process(Set annotations, + RoundEnvironment roundEnv) { + int errors = 0; + boolean processingOver = roundEnv.processingOver(); + + if (!processingOver && round == 1) { + errors += expectIllegalArgumentException(null); + errors += expectIllegalArgumentException(this); + + // Generate source code with various constant values and + // make sure it compiles. + + try { + PrintWriter pw = new PrintWriter(filer.createSourceFile("ConstantTest").openWriter()); + try { + Boolean[] booleans = {true, false}; + Byte[] bytes = {Byte.MIN_VALUE, -1, 0, 1, Byte.MAX_VALUE}; + Short[] shorts = {Short.MIN_VALUE, -1, 0, 1, Short.MAX_VALUE}; + Integer[] ints = {Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE}; + Long[] longs = {Long.MIN_VALUE, -1L, 0L,1L, Long.MAX_VALUE}; + Character[] chars = {Character.MIN_VALUE, ' ', '\t', 'a', 'b', 'c', '~', Character.MAX_VALUE}; + Float[] floats = {Float.NaN, Float.NEGATIVE_INFINITY, -1.0f, -0.0f, 0.0f, 1.0f, Float.POSITIVE_INFINITY}; + Double[] doubles = {Double.NaN, Double.NEGATIVE_INFINITY, -1.0, -0.0, 0.0, 1.0, Double.POSITIVE_INFINITY}; + + pw.println("class ConstantTest {"); + pw.println(String.format(" private static boolean[] booleans = {%s};", + printConstants(booleans))); + pw.println(String.format(" private static byte[] bytes = {%s};", + printConstants(bytes))); + pw.println(String.format(" private static short[] shorts = {%s};", + printConstants(shorts))); + pw.println(String.format(" private static int[] ints = {%s};", + printConstants(ints))); + pw.println(String.format(" private static long[] longs = {%s};", + printConstants(longs))); + pw.println(String.format(" private static char[] chars = {%s};", + printConstants(chars))); + pw.println(String.format(" private static float[] floats = {%s};", + printConstants(floats))); + pw.println(String.format(" private static double[] doubles = {%s};", + printConstants(doubles))); + pw.println("}"); + } finally { + pw.close(); + } + } catch(IOException io) { + throw new RuntimeException(io); + } + round++; + } else if (processingOver) { + if (errors > 0) { + throw new RuntimeException(); + } + } + return true; + } + + String printConstants(Object[] constants) { + StringBuilder sb = new StringBuilder(); + + for(Object o : constants) { + sb.append(eltUtils.getConstantExpression(o)); + sb.append(", "); + } + return sb.toString(); + } + + int expectIllegalArgumentException(Object o) { + String s = ""; + try { + s = eltUtils.getConstantExpression(o); + System.err.println("Unexpected string returned: " + s); + return 1; + } catch (IllegalArgumentException iae) { + return 0; + } + } + + public SourceVersion getSupportedSourceVersion() { + return SourceVersion.latest(); + } + + public void init(ProcessingEnvironment processingEnv) { + super.init(processingEnv); + eltUtils = processingEnv.getElementUtils(); + filer = processingEnv.getFiler(); + } +}