1 /*

     2  * Copyright (c) 2007, 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.tools.javap;

    27 

    28 import java.net.URI;

    29 import java.text.DateFormat;

    30 import java.util.Collection;

    31 import java.util.Date;

    32 import java.util.List;

    33 

    34 import com.sun.tools.classfile.AccessFlags;

    35 import com.sun.tools.classfile.Attribute;

    36 import com.sun.tools.classfile.Attributes;

    37 import com.sun.tools.classfile.ClassFile;

    38 import com.sun.tools.classfile.Code_attribute;

    39 import com.sun.tools.classfile.ConstantPool;

    40 import com.sun.tools.classfile.ConstantPoolException;

    41 import com.sun.tools.classfile.ConstantValue_attribute;

    42 import com.sun.tools.classfile.Descriptor;

    43 import com.sun.tools.classfile.DescriptorException;

    44 import com.sun.tools.classfile.Exceptions_attribute;

    45 import com.sun.tools.classfile.Field;

    46 import com.sun.tools.classfile.Method;

    47 import com.sun.tools.classfile.Signature;

    48 import com.sun.tools.classfile.Signature_attribute;

    49 import com.sun.tools.classfile.SourceFile_attribute;

    50 import com.sun.tools.classfile.Type;

    51 import com.sun.tools.classfile.Type.ArrayType;

    52 import com.sun.tools.classfile.Type.ClassSigType;

    53 import com.sun.tools.classfile.Type.ClassType;

    54 import com.sun.tools.classfile.Type.MethodType;

    55 import com.sun.tools.classfile.Type.SimpleType;

    56 import com.sun.tools.classfile.Type.TypeParamType;

    57 import com.sun.tools.classfile.Type.WildcardType;

    58 

    59 import static com.sun.tools.classfile.AccessFlags.*;

    60 

    61 /*

    62  *  The main javap class to write the contents of a class file as text.

    63  *

    64  *  <p><b>This is NOT part of any supported API.

    65  *  If you write code that depends on this, you do so at your own risk.

    66  *  This code and its internal interfaces are subject to change or

    67  *  deletion without notice.</b>

    68  */

    69 public class ClassWriter extends BasicWriter {

    70     static ClassWriter instance(Context context) {

    71         ClassWriter instance = context.get(ClassWriter.class);

    72         if (instance == null)

    73             instance = new ClassWriter(context);

    74         return instance;

    75     }

    76 

    77     protected ClassWriter(Context context) {

    78         super(context);

    79         context.put(ClassWriter.class, this);

    80         options = Options.instance(context);

    81         attrWriter = AttributeWriter.instance(context);

    82         codeWriter = CodeWriter.instance(context);

    83         constantWriter = ConstantWriter.instance(context);

    84     }

    85 

    86     void setDigest(String name, byte[] digest) {

    87         this.digestName = name;

    88         this.digest = digest;

    89     }

    90 

    91     void setFile(URI uri) {

    92         this.uri = uri;

    93     }

    94 

    95     void setFileSize(int size) {

    96         this.size = size;

    97     }

    98 

    99     void setLastModified(long lastModified) {

   100         this.lastModified = lastModified;

   101     }

   102 

   103     protected ClassFile getClassFile() {

   104         return classFile;

   105     }

   106 

   107     protected void setClassFile(ClassFile cf) {

   108         classFile = cf;

   109         constant_pool = classFile.constant_pool;

   110     }

   111 

   112     protected Method getMethod() {

   113         return method;

   114     }

   115 

   116     protected void setMethod(Method m) {

   117         method = m;

   118     }

   119 

   120     public void write(ClassFile cf) {

   121         setClassFile(cf);

   122 

   123         if (options.sysInfo || options.verbose) {

   124             if (uri != null) {

   125                 if (uri.getScheme().equals("file"))

   126                     println("Classfile " + uri.getPath());

   127                 else

   128                     println("Classfile " + uri);

   129             }

   130             indent(+1);

   131             if (lastModified != -1) {

   132                 Date lm = new Date(lastModified);

   133                 DateFormat df = DateFormat.getDateInstance();

   134                 if (size > 0) {

   135                     println("Last modified " + df.format(lm) + "; size " + size + " bytes");

   136                 } else {

   137                     println("Last modified " + df.format(lm));

   138                 }

   139             } else if (size > 0) {

   140                 println("Size " + size + " bytes");

   141             }

   142             if (digestName != null && digest != null) {

   143                 StringBuilder sb = new StringBuilder();

   144                 for (byte b: digest)

   145                     sb.append(String.format("%02x", b));

   146                 println(digestName + " checksum " + sb);

   147             }

   148         }

   149 

   150         Attribute sfa = cf.getAttribute(Attribute.SourceFile);

   151         if (sfa instanceof SourceFile_attribute) {

   152             println("Compiled from \"" + getSourceFile((SourceFile_attribute) sfa) + "\"");

   153         }

   154 

   155         if (options.sysInfo || options.verbose) {

   156             indent(-1);

   157         }

   158 

   159         String name = getJavaName(classFile);

   160         AccessFlags flags = cf.access_flags;

   161 

   162         writeModifiers(flags.getClassModifiers());

   163 

   164         if (classFile.isClass())

   165             print("class ");

   166         else if (classFile.isInterface())

   167             print("interface ");

   168 

   169         print(name);

   170 

   171         Signature_attribute sigAttr = getSignature(cf.attributes);

   172         if (sigAttr == null) {

   173             // use info from class file header

   174             if (classFile.isClass() && classFile.super_class != 0 ) {

   175                 String sn = getJavaSuperclassName(cf);

   176                 if (!sn.equals("java.lang.Object")) {

   177                     print(" extends ");

   178                     print(sn);

   179                 }

   180             }

   181             for (int i = 0; i < classFile.interfaces.length; i++) {

   182                 print(i == 0 ? (classFile.isClass() ? " implements " : " extends ") : ",");

   183                 print(getJavaInterfaceName(classFile, i));

   184             }

   185         } else {

   186             try {

   187                 Type t = sigAttr.getParsedSignature().getType(constant_pool);

   188                 JavaTypePrinter p = new JavaTypePrinter(classFile.isInterface());

   189                 // The signature parser cannot disambiguate between a

   190                 // FieldType and a ClassSignatureType that only contains a superclass type.

   191                 if (t instanceof Type.ClassSigType) {

   192                     print(p.print(t));

   193                 } else if (options.verbose || !t.isObject()) {

   194                     print(" extends ");

   195                     print(p.print(t));

   196                 }

   197             } catch (ConstantPoolException e) {

   198                 print(report(e));

   199             }

   200         }

   201 

   202         if (options.verbose) {

   203             println();

   204             indent(+1);

   205             println("minor version: " + cf.minor_version);

   206             println("major version: " + cf.major_version);

   207             writeList("flags: ", flags.getClassFlags(), "\n");

   208             indent(-1);

   209             constantWriter.writeConstantPool();

   210         } else {

   211             print(" ");

   212         }

   213 

   214         println("{");

   215         indent(+1);

   216         writeFields();

   217         writeMethods();

   218         indent(-1);

   219         println("}");

   220 

   221         if (options.verbose) {

   222             attrWriter.write(cf, cf.attributes, constant_pool);

   223         }

   224     }

   225     // where

   226         class JavaTypePrinter implements Type.Visitor<StringBuilder,StringBuilder> {

   227             boolean isInterface;

   228 

   229             JavaTypePrinter(boolean isInterface) {

   230                 this.isInterface = isInterface;

   231             }

   232 

   233             String print(Type t) {

   234                 return t.accept(this, new StringBuilder()).toString();

   235             }

   236 

   237             String printTypeArgs(List<? extends TypeParamType> typeParamTypes) {

   238                 StringBuilder builder = new StringBuilder();

   239                 appendIfNotEmpty(builder, "<", typeParamTypes, "> ");

   240                 return builder.toString();

   241             }

   242 

   243             public StringBuilder visitSimpleType(SimpleType type, StringBuilder sb) {

   244                 sb.append(getJavaName(type.name));

   245                 return sb;

   246             }

   247 

   248             public StringBuilder visitArrayType(ArrayType type, StringBuilder sb) {

   249                 append(sb, type.elemType);

   250                 sb.append("[]");

   251                 return sb;

   252             }

   253 

   254             public StringBuilder visitMethodType(MethodType type, StringBuilder sb) {

   255                 appendIfNotEmpty(sb, "<", type.typeParamTypes, "> ");

   256                 append(sb, type.returnType);

   257                 append(sb, " (", type.paramTypes, ")");

   258                 appendIfNotEmpty(sb, " throws ", type.throwsTypes, "");

   259                 return sb;

   260             }

   261 

   262             public StringBuilder visitClassSigType(ClassSigType type, StringBuilder sb) {

   263                 appendIfNotEmpty(sb, "<", type.typeParamTypes, ">");

   264                 if (isInterface) {

   265                     appendIfNotEmpty(sb, " extends ", type.superinterfaceTypes, "");

   266                 } else {

   267                     if (type.superclassType != null

   268                             && (options.verbose || !type.superclassType.isObject())) {

   269                         sb.append(" extends ");

   270                         append(sb, type.superclassType);

   271                     }

   272                     appendIfNotEmpty(sb, " implements ", type.superinterfaceTypes, "");

   273                 }

   274                 return sb;

   275             }

   276 

   277             public StringBuilder visitClassType(ClassType type, StringBuilder sb) {

   278                 if (type.outerType != null) {

   279                     append(sb, type.outerType);

   280                     sb.append(".");

   281                 }

   282                 sb.append(getJavaName(type.name));

   283                 appendIfNotEmpty(sb, "<", type.typeArgs, ">");

   284                 return sb;

   285             }

   286 

   287             public StringBuilder visitTypeParamType(TypeParamType type, StringBuilder sb) {

   288                 sb.append(type.name);

   289                 String sep = " extends ";

   290                 if (type.classBound != null

   291                         && (options.verbose || !type.classBound.isObject())) {

   292                     sb.append(sep);

   293                     append(sb, type.classBound);

   294                     sep = " & ";

   295                 }

   296                 if (type.interfaceBounds != null) {

   297                     for (Type bound: type.interfaceBounds) {

   298                         sb.append(sep);

   299                         append(sb, bound);

   300                         sep = " & ";

   301                     }

   302                 }

   303                 return sb;

   304             }

   305 

   306             public StringBuilder visitWildcardType(WildcardType type, StringBuilder sb) {

   307                 switch (type.kind) {

   308                     case UNBOUNDED:

   309                         sb.append("?");

   310                         break;

   311                     case EXTENDS:

   312                         sb.append("? extends ");

   313                         append(sb, type.boundType);

   314                         break;

   315                     case SUPER:

   316                         sb.append("? super ");

   317                         append(sb, type.boundType);

   318                         break;

   319                     default:

   320                         throw new AssertionError();

   321                 }

   322                 return sb;

   323             }

   324 

   325             private void append(StringBuilder sb, Type t) {

   326                 t.accept(this, sb);

   327             }

   328 

   329             private void append(StringBuilder sb, String prefix, List<? extends Type> list, String suffix) {

   330                 sb.append(prefix);

   331                 String sep = "";

   332                 for (Type t: list) {

   333                     sb.append(sep);

   334                     append(sb, t);

   335                     sep = ", ";

   336                 }

   337                 sb.append(suffix);

   338             }

   339 

   340             private void appendIfNotEmpty(StringBuilder sb, String prefix, List<? extends Type> list, String suffix) {

   341                 if (!isEmpty(list))

   342                     append(sb, prefix, list, suffix);

   343             }

   344 

   345             private boolean isEmpty(List<? extends Type> list) {

   346                 return (list == null || list.isEmpty());

   347             }

   348         }

   349 

   350     protected void writeFields() {

   351         for (Field f: classFile.fields) {

   352             writeField(f);

   353         }

   354     }

   355 

   356     protected void writeField(Field f) {

   357         if (!options.checkAccess(f.access_flags))

   358             return;

   359 

   360         AccessFlags flags = f.access_flags;

   361         writeModifiers(flags.getFieldModifiers());

   362         Signature_attribute sigAttr = getSignature(f.attributes);

   363         if (sigAttr == null)

   364             print(getJavaFieldType(f.descriptor));

   365         else {

   366             try {

   367                 Type t = sigAttr.getParsedSignature().getType(constant_pool);

   368                 print(getJavaName(t.toString()));

   369             } catch (ConstantPoolException e) {

   370                 // report error?

   371                 // fall back on non-generic descriptor

   372                 print(getJavaFieldType(f.descriptor));

   373             }

   374         }

   375         print(" ");

   376         print(getFieldName(f));

   377         if (options.showConstants) {

   378             Attribute a = f.attributes.get(Attribute.ConstantValue);

   379             if (a instanceof ConstantValue_attribute) {

   380                 print(" = ");

   381                 ConstantValue_attribute cv = (ConstantValue_attribute) a;

   382                 print(getConstantValue(f.descriptor, cv.constantvalue_index));

   383             }

   384         }

   385         print(";");

   386         println();

   387 

   388         indent(+1);

   389 

   390         boolean showBlank = false;

   391 

   392         if (options.showDescriptors)

   393             println("descriptor: " + getValue(f.descriptor));

   394 

   395         if (options.verbose)

   396             writeList("flags: ", flags.getFieldFlags(), "\n");

   397 

   398         if (options.showAllAttrs) {

   399             for (Attribute attr: f.attributes)

   400                 attrWriter.write(f, attr, constant_pool);

   401             showBlank = true;

   402         }

   403 

   404         indent(-1);

   405 

   406         if (showBlank || options.showDisassembled || options.showLineAndLocalVariableTables)

   407             println();

   408     }

   409 

   410     protected void writeMethods() {

   411         for (Method m: classFile.methods)

   412             writeMethod(m);

   413         setPendingNewline(false);

   414     }

   415 

   416     protected void writeMethod(Method m) {

   417         if (!options.checkAccess(m.access_flags))

   418             return;

   419 

   420         method = m;

   421 

   422         AccessFlags flags = m.access_flags;

   423 

   424         Descriptor d;

   425         Type.MethodType methodType;

   426         List<? extends Type> methodExceptions;

   427 

   428         Signature_attribute sigAttr = getSignature(m.attributes);

   429         if (sigAttr == null) {

   430             d = m.descriptor;

   431             methodType = null;

   432             methodExceptions = null;

   433         } else {

   434             Signature methodSig = sigAttr.getParsedSignature();

   435             d = methodSig;

   436             try {

   437                 methodType = (Type.MethodType) methodSig.getType(constant_pool);

   438                 methodExceptions = methodType.throwsTypes;

   439                 if (methodExceptions != null && methodExceptions.isEmpty())

   440                     methodExceptions = null;

   441             } catch (ConstantPoolException e) {

   442                 // report error?

   443                 // fall back on standard descriptor

   444                 methodType = null;

   445                 methodExceptions = null;

   446             }

   447         }

   448 

   449         writeModifiers(flags.getMethodModifiers());

   450         if (methodType != null) {

   451             print(new JavaTypePrinter(false).printTypeArgs(methodType.typeParamTypes));

   452         }

   453         if (getName(m).equals("<init>")) {

   454             print(getJavaName(classFile));

   455             print(getJavaParameterTypes(d, flags));

   456         } else if (getName(m).equals("<clinit>")) {

   457             print("{}");

   458         } else {

   459             print(getJavaReturnType(d));

   460             print(" ");

   461             print(getName(m));

   462             print(getJavaParameterTypes(d, flags));

   463         }

   464 

   465         Attribute e_attr = m.attributes.get(Attribute.Exceptions);

   466         if (e_attr != null) { // if there are generic exceptions, there must be erased exceptions

   467             if (e_attr instanceof Exceptions_attribute) {

   468                 Exceptions_attribute exceptions = (Exceptions_attribute) e_attr;

   469                 print(" throws ");

   470                 if (methodExceptions != null) { // use generic list if available

   471                     writeList("", methodExceptions, "");

   472                 } else {

   473                     for (int i = 0; i < exceptions.number_of_exceptions; i++) {

   474                         if (i > 0)

   475                             print(", ");

   476                         print(getJavaException(exceptions, i));

   477                     }

   478                 }

   479             } else {

   480                 report("Unexpected or invalid value for Exceptions attribute");

   481             }

   482         }

   483 

   484         println(";");

   485 

   486         indent(+1);

   487 

   488         if (options.showDescriptors) {

   489             println("descriptor: " + getValue(m.descriptor));

   490         }

   491 

   492         if (options.verbose) {

   493             writeList("flags: ", flags.getMethodFlags(), "\n");

   494         }

   495 

   496         Code_attribute code = null;

   497         Attribute c_attr = m.attributes.get(Attribute.Code);

   498         if (c_attr != null) {

   499             if (c_attr instanceof Code_attribute)

   500                 code = (Code_attribute) c_attr;

   501             else

   502                 report("Unexpected or invalid value for Code attribute");

   503         }

   504 

   505         if (options.showAllAttrs) {

   506             Attribute[] attrs = m.attributes.attrs;

   507             for (Attribute attr: attrs)

   508                 attrWriter.write(m, attr, constant_pool);

   509         } else if (code != null) {

   510             if (options.showDisassembled) {

   511                 println("Code:");

   512                 codeWriter.writeInstrs(code);

   513                 codeWriter.writeExceptionTable(code);

   514             }

   515 

   516             if (options.showLineAndLocalVariableTables) {

   517                 attrWriter.write(code, code.attributes.get(Attribute.LineNumberTable), constant_pool);

   518                 attrWriter.write(code, code.attributes.get(Attribute.LocalVariableTable), constant_pool);

   519             }

   520         }

   521 

   522         indent(-1);

   523 

   524         // set pendingNewline to write a newline before the next method (if any)

   525         // if a separator is desired

   526         setPendingNewline(

   527                 options.showDisassembled ||

   528                 options.showAllAttrs ||

   529                 options.showDescriptors ||

   530                 options.showLineAndLocalVariableTables ||

   531                 options.verbose);

   532     }

   533 

   534     void writeModifiers(Collection<String> items) {

   535         for (Object item: items) {

   536             print(item);

   537             print(" ");

   538         }

   539     }

   540 

   541     void writeList(String prefix, Collection<?> items, String suffix) {

   542         print(prefix);

   543         String sep = "";

   544         for (Object item: items) {

   545             print(sep);

   546             print(item);

   547             sep = ", ";

   548         }

   549         print(suffix);

   550     }

   551 

   552     void writeListIfNotEmpty(String prefix, List<?> items, String suffix) {

   553         if (items != null && items.size() > 0)

   554             writeList(prefix, items, suffix);

   555     }

   556 

   557     Signature_attribute getSignature(Attributes attributes) {

   558         return (Signature_attribute) attributes.get(Attribute.Signature);

   559     }

   560 

   561     String adjustVarargs(AccessFlags flags, String params) {

   562         if (flags.is(ACC_VARARGS)) {

   563             int i = params.lastIndexOf("[]");

   564             if (i > 0)

   565                 return params.substring(0, i) + "..." + params.substring(i+2);

   566         }

   567 

   568         return params;

   569     }

   570 

   571     String getJavaName(ClassFile cf) {

   572         try {

   573             return getJavaName(cf.getName());

   574         } catch (ConstantPoolException e) {

   575             return report(e);

   576         }

   577     }

   578 

   579     String getJavaSuperclassName(ClassFile cf) {

   580         try {

   581             return getJavaName(cf.getSuperclassName());

   582         } catch (ConstantPoolException e) {

   583             return report(e);

   584         }

   585     }

   586 

   587     String getJavaInterfaceName(ClassFile cf, int index) {

   588         try {

   589             return getJavaName(cf.getInterfaceName(index));

   590         } catch (ConstantPoolException e) {

   591             return report(e);

   592         }

   593     }

   594 

   595     String getJavaFieldType(Descriptor d) {

   596         try {

   597             return getJavaName(d.getFieldType(constant_pool));

   598         } catch (ConstantPoolException e) {

   599             return report(e);

   600         } catch (DescriptorException e) {

   601             return report(e);

   602         }

   603     }

   604 

   605     String getJavaReturnType(Descriptor d) {

   606         try {

   607             return getJavaName(d.getReturnType(constant_pool));

   608         } catch (ConstantPoolException e) {

   609             return report(e);

   610         } catch (DescriptorException e) {

   611             return report(e);

   612         }

   613     }

   614 

   615     String getJavaParameterTypes(Descriptor d, AccessFlags flags) {

   616         try {

   617             return getJavaName(adjustVarargs(flags, d.getParameterTypes(constant_pool)));

   618         } catch (ConstantPoolException e) {

   619             return report(e);

   620         } catch (DescriptorException e) {

   621             return report(e);

   622         }

   623     }

   624 

   625     String getJavaException(Exceptions_attribute attr, int index) {

   626         try {

   627             return getJavaName(attr.getException(index, constant_pool));

   628         } catch (ConstantPoolException e) {

   629             return report(e);

   630         }

   631     }

   632 

   633     String getValue(Descriptor d) {

   634         try {

   635             return d.getValue(constant_pool);

   636         } catch (ConstantPoolException e) {

   637             return report(e);

   638         }

   639     }

   640 

   641     String getFieldName(Field f) {

   642         try {

   643             return f.getName(constant_pool);

   644         } catch (ConstantPoolException e) {

   645             return report(e);

   646         }

   647     }

   648 

   649     String getName(Method m) {

   650         try {

   651             return m.getName(constant_pool);

   652         } catch (ConstantPoolException e) {

   653             return report(e);

   654         }

   655     }

   656 

   657     static String getJavaName(String name) {

   658         return name.replace('/', '.');

   659     }

   660 

   661     String getSourceFile(SourceFile_attribute attr) {

   662         try {

   663             return attr.getSourceFile(constant_pool);

   664         } catch (ConstantPoolException e) {

   665             return report(e);

   666         }

   667     }

   668 

   669     /**

   670      * Get the value of an entry in the constant pool as a Java constant.

   671      * Characters and booleans are represented by CONSTANT_Intgere entries.

   672      * Character and string values are processed to escape characters outside

   673      * the basic printable ASCII set.

   674      * @param d the descriptor, giving the expected type of the constant

   675      * @param index the index of the value in the constant pool

   676      * @return a printable string containing the value of the constant.

   677      */

   678     String getConstantValue(Descriptor d, int index) {

   679         try {

   680             ConstantPool.CPInfo cpInfo = constant_pool.get(index);

   681 

   682             switch (cpInfo.getTag()) {

   683                 case ConstantPool.CONSTANT_Integer: {

   684                     ConstantPool.CONSTANT_Integer_info info =

   685                             (ConstantPool.CONSTANT_Integer_info) cpInfo;

   686                     String t = d.getValue(constant_pool);

   687                     if (t.equals("C")) { // character

   688                         return getConstantCharValue((char) info.value);

   689                     } else if (t.equals("Z")) { // boolean

   690                         return String.valueOf(info.value == 1);

   691                     } else { // other: assume integer

   692                         return String.valueOf(info.value);

   693                     }

   694                 }

   695 

   696                 case ConstantPool.CONSTANT_String: {

   697                     ConstantPool.CONSTANT_String_info info =

   698                             (ConstantPool.CONSTANT_String_info) cpInfo;

   699                     return getConstantStringValue(info.getString());

   700                 }

   701 

   702                 default:

   703                     return constantWriter.stringValue(cpInfo);

   704             }

   705         } catch (ConstantPoolException e) {

   706             return "#" + index;

   707         }

   708     }

   709 

   710     private String getConstantCharValue(char c) {

   711         StringBuilder sb = new StringBuilder();

   712         sb.append('\'');

   713         sb.append(esc(c, '\''));

   714         sb.append('\'');

   715         return sb.toString();

   716     }

   717 

   718     private String getConstantStringValue(String s) {

   719         StringBuilder sb = new StringBuilder();

   720         sb.append("\"");

   721         for (int i = 0; i < s.length(); i++) {

   722             sb.append(esc(s.charAt(i), '"'));

   723         }

   724         sb.append("\"");

   725         return sb.toString();

   726     }

   727 

   728     private String esc(char c, char quote) {

   729         if (32 <= c && c <= 126 && c != quote)

   730             return String.valueOf(c);

   731         else switch (c) {

   732             case '\b': return "\\b";

   733             case '\n': return "\\n";

   734             case '\t': return "\\t";

   735             case '\f': return "\\f";

   736             case '\r': return "\\r";

   737             case '\\': return "\\\\";

   738             case '\'': return "\\'";

   739             case '\"': return "\\\"";

   740             default:   return String.format("\\u%04x", (int) c);

   741         }

   742     }

   743 

   744     private Options options;

   745     private AttributeWriter attrWriter;

   746     private CodeWriter codeWriter;

   747     private ConstantWriter constantWriter;

   748     private ClassFile classFile;

   749     private URI uri;

   750     private long lastModified;

   751     private String digestName;

   752     private byte[] digest;

   753     private int size;

   754     private ConstantPool constant_pool;

   755     private Method method;

   756 }