Java > Open Source Codes > com > sun > org > apache > bcel > internal > classfile > Utility


1 package com.sun.org.apache.bcel.internal.classfile;
2
3 /* ====================================================================
4  * The Apache Software License, Version 1.1
5  *
6  * Copyright (c) 2001 The Apache Software Foundation. All rights
7  * reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright
14  * notice, this list of conditions and the following disclaimer.
15  *
16  * 2. Redistributions in binary form must reproduce the above copyright
17  * notice, this list of conditions and the following disclaimer in
18  * the documentation and/or other materials provided with the
19  * distribution.
20  *
21  * 3. The end-user documentation included with the redistribution,
22  * if any, must include the following acknowledgment:
23  * "This product includes software developed by the
24  * Apache Software Foundation (http://www.apache.org/)."
25  * Alternately, this acknowledgment may appear in the software itself,
26  * if and wherever such third-party acknowledgments normally appear.
27  *
28  * 4. The names "Apache" and "Apache Software Foundation" and
29  * "Apache BCEL" must not be used to endorse or promote products
30  * derived from this software without prior written permission. For
31  * written permission, please contact apache@apache.org.
32  *
33  * 5. Products derived from this software may not be called "Apache",
34  * "Apache BCEL", nor may "Apache" appear in their name, without
35  * prior written permission of the Apache Software Foundation.
36  *
37  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40  * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
41  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
44  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
45  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
46  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
47  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
48  * SUCH DAMAGE.
49  * ====================================================================
50  *
51  * This software consists of voluntary contributions made by many
52  * individuals on behalf of the Apache Software Foundation. For more
53  * information on the Apache Software Foundation, please see
54  * <http://www.apache.org/>.
55  */
56
57 import com.sun.org.apache.bcel.internal.Constants;
58 import com.sun.org.apache.bcel.internal.util.ByteSequence;
59 import java.io.*;
60 import java.util.ArrayList ;
61 import java.util.zip.*;
62
63 /**
64  * Utility functions that do not really belong to any class in particular.
65  *
66  * @version $Id: Utility.java,v 1.1.1.1 2001/10/29 20:00:05 jvanzyl Exp $
67  * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
68  */
69 public abstract class Utility {
70   private static int consumed_chars; /* How many chars have been consumed
71                       * during parsing in signatureToString().
72                       * Read by methodSignatureToString().
73                       * Set by side effect,but only internally.
74                       */
75   private static boolean wide=false; /* The `WIDE' instruction is used in the
76                       * byte code to allow 16-bit wide indices
77                       * for local variables. This opcode
78                       * precedes an `ILOAD', e.g.. The opcode
79                       * immediately following takes an extra
80                       * byte which is combined with the
81                       * following byte to form a
82                       * 16-bit value.
83                       */
84   /**
85    * Convert bit field of flags into string such as `static final'.
86    *
87    * @param access_flags Access flags
88    * @return String representation of flags
89    */
90   public static final String accessToString(int access_flags) {
91     return accessToString(access_flags, false);
92   }
93
94   /**
95    * Convert bit field of flags into string such as `static final'.
96    *
97    * Special case: Classes compiled with new compilers and with the
98    * `ACC_SUPER' flag would be said to be "synchronized". This is
99    * because SUN used the same value for the flags `ACC_SUPER' and
100    * `ACC_SYNCHRONIZED'.
101    *
102    * @param access_flags Access flags
103    * @param for_class access flags are for class qualifiers ?
104    * @return String representation of flags
105    */
106   public static final String accessToString(int access_flags,
107                         boolean for_class)
108   {
109     StringBuffer buf = new StringBuffer ();
110
111     int p = 0;
112     for(int i=0; p < Constants.MAX_ACC_FLAG; i++) { // Loop through known flags
113 p = pow2(i);
114
115       if((access_flags & p) != 0) {
116     /* Special case: Classes compiled with new compilers and with the
117      * `ACC_SUPER' flag would be said to be "synchronized". This is
118      * because SUN used the same value for the flags `ACC_SUPER' and
119      * `ACC_SYNCHRONIZED'.
120      */
121     if(for_class && ((p == Constants.ACC_SUPER) || (p == Constants.ACC_INTERFACE)))
122       continue;
123
124     buf.append(Constants.ACCESS_NAMES[i] + " ");
125       }
126     }
127
128     return buf.toString().trim();
129   }
130
131   /**
132    * @return "class" or "interface", depending on the ACC_INTERFACE flag
133    */
134   public static final String classOrInterface(int access_flags) {
135     return ((access_flags & Constants.ACC_INTERFACE) != 0)? "interface" : "class";
136   }
137
138   /**
139    * Disassemble a byte array of JVM byte codes starting from code line
140    * `index' and return the disassembled string representation. Decode only
141    * `num' opcodes (including their operands), use -1 if you want to
142    * decompile everything.
143    *
144    * @param code byte code array
145    * @param constant_pool Array of constants
146    * @param index offset in `code' array
147    * <EM>(number of opcodes, not bytes!)</EM>
148    * @param length number of opcodes to decompile, -1 for all
149    * @param verbose be verbose, e.g. print constant pool index
150    * @return String representation of byte codes
151    */
152   public static final String codeToString(byte[] code,
153                       ConstantPool constant_pool,
154                       int index, int length, boolean verbose)
155   {
156     StringBuffer buf = new StringBuffer (code.length * 20); // Should be sufficient
157 ByteSequence stream = new ByteSequence(code);
158
159     try {
160       for(int i=0; i < index; i++) // Skip `index' lines of code
161 codeToString(stream, constant_pool, verbose);
162
163       for(int i=0; stream.available() > 0; i++) {
164     if((length < 0) || (i < length)) {
165       String indices = fillup(stream.getIndex() + ":", 6, true, ' ');
166       buf.append(indices + codeToString(stream, constant_pool, verbose) + '\n');
167     }
168       }
169     } catch(IOException e) {
170       System.out.println(buf.toString());
171       e.printStackTrace();
172       throw new ClassFormatError ("Byte code error: " + e);
173     }
174
175     return buf.toString();
176   }
177
178   public static final String codeToString(byte[] code,
179                       ConstantPool constant_pool,
180                       int index, int length) {
181     return codeToString(code, constant_pool, index, length, true);
182   }
183
184   /**
185    * Disassemble a stream of byte codes and return the
186    * string representation.
187    *
188    * @param bytes stream of bytes
189    * @param constant_pool Array of constants
190    * @param verbose be verbose, e.g. print constant pool index
191    * @return String representation of byte code
192    */
193   public static final String codeToString(ByteSequence bytes,
194                       ConstantPool constant_pool, boolean verbose)
195        throws IOException
196   {
197     short opcode = (short)bytes.readUnsignedByte();
198     int default_offset=0, low, high, npairs;
199     int index, vindex, constant;
200     int[] match, jump_table;
201     int no_pad_bytes=0, offset;
202     StringBuffer buf = new StringBuffer (Constants.OPCODE_NAMES[opcode]);
203
204     /* Special case: Skip (0-3) padding bytes, i.e., the
205      * following bytes are 4-byte-aligned
206      */
207     if((opcode == Constants.TABLESWITCH) || (opcode == Constants.LOOKUPSWITCH)) {
208       int remainder = bytes.getIndex() % 4;
209       no_pad_bytes = (remainder == 0)? 0 : 4 - remainder;
210
211       for(int i=0; i < no_pad_bytes; i++) {
212     byte b;
213
214     if((b=bytes.readByte()) != 0)
215       System.err.println("Warning: Padding byte != 0 in " +
216                  Constants.OPCODE_NAMES[opcode] + ":" + b);
217       }
218
219       // Both cases have a field default_offset in common
220 default_offset = bytes.readInt();
221     }
222
223     switch(opcode) {
224       /* Table switch has variable length arguments.
225        */
226     case Constants.TABLESWITCH:
227       low = bytes.readInt();
228       high = bytes.readInt();
229
230       offset = bytes.getIndex() - 12 - no_pad_bytes - 1;
231       default_offset += offset;
232
233       buf.append("\tdefault = " + default_offset + ", low = " + low +
234          ", high = " + high + "(");
235
236       jump_table = new int[high - low + 1];
237       for(int i=0; i < jump_table.length; i++) {
238     jump_table[i] = offset + bytes.readInt();
239     buf.append(jump_table[i]);
240
241     if(i < jump_table.length - 1)
242       buf.append(", ");
243       }
244       buf.append(")");
245
246       break;
247
248       /* Lookup switch has variable length arguments.
249        */
250     case Constants.LOOKUPSWITCH: {
251
252       npairs = bytes.readInt();
253       offset = bytes.getIndex() - 8 - no_pad_bytes - 1;
254       
255       match = new int[npairs];
256       jump_table = new int[npairs];
257       default_offset += offset;
258
259       buf.append("\tdefault = " + default_offset + ", npairs = " + npairs +
260          " (");
261
262       for(int i=0; i < npairs; i++) {
263     match[i] = bytes.readInt();
264
265     jump_table[i] = offset + bytes.readInt();
266
267     buf.append("(" + match[i] + ", " + jump_table[i] + ")");
268
269     if(i < npairs - 1)
270       buf.append(", ");
271       }
272       buf.append(")");
273     }
274     break;
275
276     /* Two address bytes + offset from start of byte stream form the
277      * jump target
278      */
279     case Constants.GOTO: case Constants.IFEQ: case Constants.IFGE: case Constants.IFGT:
280     case Constants.IFLE: case Constants.IFLT: case Constants.JSR: case Constants.IFNE:
281     case Constants.IFNONNULL: case Constants.IFNULL: case Constants.IF_ACMPEQ:
282     case Constants.IF_ACMPNE: case Constants.IF_ICMPEQ: case Constants.IF_ICMPGE: case Constants.IF_ICMPGT:
283     case Constants.IF_ICMPLE: case Constants.IF_ICMPLT: case Constants.IF_ICMPNE:
284       buf.append("\t\t#" + ((bytes.getIndex() - 1) + bytes.readShort()));
285       break;
286       
287       /* 32-bit wide jumps
288        */
289     case Constants.GOTO_W: case Constants.JSR_W:
290       buf.append("\t\t#" + ((bytes.getIndex() - 1) + bytes.readInt()));
291       break;
292
293       /* Index byte references local variable (register)
294        */
295     case Constants.ALOAD: case Constants.ASTORE: case Constants.DLOAD: case Constants.DSTORE: case Constants.FLOAD:
296     case Constants.FSTORE: case Constants.ILOAD: case Constants.ISTORE: case Constants.LLOAD: case Constants.LSTORE:
297     case Constants.RET:
298       if(wide) {
299     vindex = bytes.readUnsignedShort();
300     wide=false; // Clear flag
301 }
302       else
303     vindex = bytes.readUnsignedByte();
304
305       buf.append("\t\t%" + vindex);
306       break;
307
308       /*
309        * Remember wide byte which is used to form a 16-bit address in the
310        * following instruction. Relies on that the method is called again with
311        * the following opcode.
312        */
313     case Constants.WIDE:
314       wide = true;
315       buf.append("\t(wide)");
316       break;
317
318       /* Array of basic type.
319        */
320     case Constants.NEWARRAY:
321       buf.append("\t\t<" + Constants.TYPE_NAMES[bytes.readByte()] + ">");
322       break;
323
324       /* Access object/class fields.
325        */
326     case Constants.GETFIELD: case Constants.GETSTATIC: case Constants.PUTFIELD: case Constants.PUTSTATIC:
327       index = bytes.readUnsignedShort();
328       buf.append("\t\t" +
329          constant_pool.constantToString(index, Constants.CONSTANT_Fieldref) +
330          (verbose? " (" + index + ")" : ""));
331       break;
332       
333       /* Operands are references to classes in constant pool
334        */
335     case Constants.NEW:
336     case Constants.CHECKCAST:
337       buf.append("\t");
338     case Constants.INSTANCEOF:
339       index = bytes.readUnsignedShort();
340       buf.append("\t<" + constant_pool.constantToString(index,
341                             Constants.CONSTANT_Class) +
342          ">" + (verbose? " (" + index + ")" : ""));
343       break;
344
345       /* Operands are references to methods in constant pool
346        */
347     case Constants.INVOKESPECIAL: case Constants.INVOKESTATIC: case Constants.INVOKEVIRTUAL:
348       index = bytes.readUnsignedShort();
349       buf.append("\t" + constant_pool.constantToString(index,
350                                Constants.CONSTANT_Methodref) +
351          (verbose? " (" + index + ")" : ""));
352       break;
353
354     case Constants.INVOKEINTERFACE:
355       index = bytes.readUnsignedShort();
356       int nargs = bytes.readUnsignedByte(); // historical, redundant
357 buf.append("\t" +
358          constant_pool.constantToString(index,
359                         Constants.CONSTANT_InterfaceMethodref) +
360          (verbose? " (" + index + ")\t" : "") + nargs + "\t" +
361          bytes.readUnsignedByte()); // Last byte is a reserved space
362 break;
363     
364       /* Operands are references to items in constant pool
365        */
366     case Constants.LDC_W: case Constants.LDC2_W:
367       index = bytes.readUnsignedShort();
368
369       buf.append("\t\t" + constant_pool.constantToString
370          (index, constant_pool.getConstant(index).getTag()) +
371          (verbose? " (" + index + ")" : ""));
372       break;
373
374     case Constants.LDC:
375       index = bytes.readUnsignedByte();
376
377       buf.append("\t\t" +
378          constant_pool.constantToString
379          (index, constant_pool.getConstant(index).getTag()) +
380          (verbose? " (" + index + ")" : ""));
381       break;
382     
383       /* Array of references.
384        */
385     case Constants.ANEWARRAY:
386       index = bytes.readUnsignedShort();
387       
388       buf.append("\t\t<" + compactClassName(constant_pool.getConstantString
389                       (index, Constants.CONSTANT_Class), false) +
390          ">" + (verbose? " (" + index + ")": ""));
391       break;
392     
393       /* Multidimensional array of references.
394        */
395     case Constants.MULTIANEWARRAY: {
396       index = bytes.readUnsignedShort();
397       int dimensions = bytes.readUnsignedByte();
398
399       buf.append("\t<" + compactClassName(constant_pool.getConstantString
400                       (index, Constants.CONSTANT_Class), false) +
401          ">\t" + dimensions + (verbose? " (" + index + ")" : ""));
402     }
403     break;
404
405     /* Increment local variable.
406      */
407     case Constants.IINC:
408       if(wide) {
409     vindex = bytes.readUnsignedShort();
410     constant = bytes.readShort();
411     wide = false;
412       }
413       else {
414     vindex = bytes.readUnsignedByte();
415     constant = bytes.readByte();
416       }
417       buf.append("\t\t%" + vindex + "\t" + constant);
418       break;
419
420     default:
421       if(Constants.NO_OF_OPERANDS[opcode] > 0) {
422     for(int i=0; i < Constants.TYPE_OF_OPERANDS[opcode].length; i++) {
423       buf.append("\t\t");
424       switch(Constants.TYPE_OF_OPERANDS[opcode][i]) {
425       case Constants.T_BYTE: buf.append(bytes.readByte()); break;
426       case Constants.T_SHORT: buf.append(bytes.readShort()); break;
427       case Constants.T_INT: buf.append(bytes.readInt()); break;
428                           
429       default: // Never reached
430 System.err.println("Unreachable default case reached!");
431         System.exit(-1);
432       }
433     }
434       }
435     }
436
437     return buf.toString();
438   }
439
440   public static final String codeToString(ByteSequence bytes, ConstantPool constant_pool)
441     throws IOException
442   {
443     return codeToString(bytes, constant_pool, true);
444   }
445
446   /**
447    * Shorten long class names, <em>java/lang/String</em> becomes
448    * <em>String</em>.
449    *
450    * @param str The long class name
451    * @return Compacted class name
452    */
453   public static final String compactClassName(String str) {
454     return compactClassName(str, true);
455   }
456  
457   /**
458    * Shorten long class name <em>str</em>, i.e., chop off the <em>prefix</em>,
459    * if the
460    * class name starts with this string and the flag <em>chopit</em> is true.
461    * Slashes <em>/</em> are converted to dots <em>.</em>.
462    *
463    * @param str The long class name
464    * @param prefix The prefix the get rid off
465    * @param chopit Flag that determines whether chopping is executed or not
466    * @return Compacted class name
467    */
468   public static final String compactClassName(String str,
469                           String prefix,
470                           boolean chopit)
471   {
472     int len = prefix.length();
473
474     str = str.replace('/', '.'); // Is `/' on all systems, even DOS
475
476     if(chopit) {
477       // If string starts with `prefix' and contains no further dots
478 if(str.startsWith(prefix) &&
479      (str.substring(len).indexOf('.') == -1))
480     str = str.substring(len);
481     }
482     
483     return str;
484   }
485
486   /**
487    * Shorten long class names, <em>java/lang/String</em> becomes
488    * <em>java.lang.String</em>,
489    * e.g.. If <em>chopit</em> is <em>true</em> the prefix <em>java.lang</em>
490    * is also removed.
491    *
492    * @param str The long class name
493    * @param chopit Flag that determines whether chopping is executed or not
494    * @return Compacted class name
495    */
496   public static final String compactClassName(String str, boolean chopit) {
497     return compactClassName(str, "java.lang.", chopit);
498   }
499
500   private static final boolean is_digit(char ch) {
501     return (ch >= '0') && (ch <= '9');
502   }
503   
504   private static final boolean is_space(char ch) {
505     return (ch == ' ') || (ch == '\t') || (ch == '\r') || (ch == '\n');
506   }
507
508   /**
509    * @return `flag' with bit `i' set to 1
510    */
511   public static final int setBit(int flag, int i) {
512     return flag | pow2(i);
513   }
514
515   /**
516    * @return `flag' with bit `i' set to 0
517    */
518   public static final int clearBit(int flag, int i) {
519     int bit = pow2(i);
520     return (flag & bit) == 0? flag : flag ^ bit;
521   }
522    
523   /**
524    * @return true, if bit `i' in `flag' is set
525    */
526   public static final boolean isSet(int flag, int i) {
527     return (flag & pow2(i)) != 0;
528   }
529
530   /**
531    * Converts string containing the method return and argument types
532    * to a byte code method signature.
533    *
534    * @param ret Return type of method
535    * @param argv Types of method arguments
536    * @return Byte code representation of method signature
537    */
538   public final static String methodTypeToSignature(String ret, String [] argv)
539     throws ClassFormatError
540   {
541     StringBuffer buf = new StringBuffer ("(");
542     String str;
543
544     if(argv != null)
545       for(int i=0; i < argv.length; i++) {
546     str = getSignature(argv[i]);
547
548     if(str.endsWith("V")) // void can't be a method argument
549 throw new ClassFormatError ("Invalid type: " + argv[i]);
550
551     buf.append(str);
552       }
553
554     str = getSignature(ret);
555
556     buf.append(")" + str);
557
558     return buf.toString();
559   }
560
561   /**
562    * @param signature Method signature
563    * @return Array of argument types
564    * @throw ClassFormatError
565    */
566   public static final String [] methodSignatureArgumentTypes(String signature)
567     throws ClassFormatError
568   {
569     return methodSignatureArgumentTypes(signature, true);
570   }
571
572   /**
573    * @param signature Method signature
574    * @param chopit Shorten class names ?
575    * @return Array of argument types
576    * @throw ClassFormatError
577    */
578   public static final String [] methodSignatureArgumentTypes(String signature,
579                                 boolean chopit)
580     throws ClassFormatError
581   {
582     ArrayList vec = new ArrayList ();
583     int index;
584     String [] types;
585
586     try { // Read all declarations between for `(' and `)'
587 if(signature.charAt(0) != '(')
588     throw new ClassFormatError ("Invalid method signature: " + signature);
589
590       index = 1; // current string position
591
592       while(signature.charAt(index) != ')') {
593     vec.add(signatureToString(signature.substring(index), chopit));
594     index += consumed_chars; // update position
595 }
596     } catch(StringIndexOutOfBoundsException e) { // Should never occur
597 throw new ClassFormatError ("Invalid method signature: " + signature);
598     }
599     
600     types = new String [vec.size()];
601     vec.toArray(types);
602     return types;
603   }
604   /**
605    * @param signature Method signature
606    * @return return type of method
607    * @throw ClassFormatError
608    */
609   public static final String methodSignatureReturnType(String signature)
610        throws ClassFormatError
611   {
612     return methodSignatureReturnType(signature, true);
613   }
614   /**
615    * @param signature Method signature
616    * @param chopit Shorten class names ?
617    * @return return type of method
618    * @throw ClassFormatError
619    */
620   public static final String methodSignatureReturnType(String signature,
621                                boolean chopit)
622        throws ClassFormatError
623   {
624     int index;
625     String type;
626
627     try {
628       // Read return type after `)'
629 index = signature.lastIndexOf(')') + 1;
630       type = signatureToString(signature.substring(index), chopit);
631     } catch(StringIndexOutOfBoundsException e) { // Should never occur
632 throw new ClassFormatError ("Invalid method signature: " + signature);
633     }
634
635     return type;
636   }
637
638   /**
639    * Converts method signature to string with all class names compacted.
640    *
641    * @param signature to convert
642    * @param name of method
643    * @param access flags of method
644    * @return Human readable signature
645    */
646   public static final String methodSignatureToString(String signature,
647                              String name,
648                              String access) {
649     return methodSignatureToString(signature, name, access, true);
650   }
651
652   public static final String methodSignatureToString(String signature,
653                              String name,
654                              String access,
655                              boolean chopit) {
656     return methodSignatureToString(signature, name, access, chopit, null);
657   }
658
659   /**
660    * A return&#255;type signature represents the return value from a method.
661    * It is a series of bytes in the following grammar:
662    *
663    * <return_signature> ::= <field_type> | V
664    *
665    * The character V indicates that the method returns no value. Otherwise, the
666    * signature indicates the type of the return value.
667    * An argument signature represents an argument passed to a method:
668    *
669    * <argument_signature> ::= <field_type>
670    *
671    * A method signature represents the arguments that the method expects, and
672    * the value that it returns.
673    * <method_signature> ::= (<arguments_signature>) <return_signature>
674    * <arguments_signature>::= <argument_signature>*
675    *
676    * This method converts such a string into a Java type declaration like
677    * `void main(String[])' and throws a `ClassFormatError' when the parsed
678    * type is invalid.
679    *
680    * @param signature Method signature
681    * @param name Method name
682    * @param access Method access rights
683    * @return Java type declaration
684    * @throw ClassFormatError
685    */
686   public static final String methodSignatureToString(String signature,
687                              String name,
688                              String access,
689                              boolean chopit,
690                              LocalVariableTable vars)
691     throws ClassFormatError
692   {
693     StringBuffer buf = new StringBuffer ("(");
694     String type;
695     int index;
696     int var_index = (access.indexOf("static") >= 0)? 0 : 1;
697
698     try { // Read all declarations between for `(' and `)'
699 if(signature.charAt(0) != '(')
700     throw new ClassFormatError ("Invalid method signature: " + signature);
701
702       index = 1; // current string position
703
704       while(signature.charAt(index) != ')') {
705     buf.append(signatureToString(signature.substring(index), chopit));
706
707     if(vars != null) {
708       LocalVariable l = vars.getLocalVariable(var_index);
709
710       if(l != null)
711         buf.append(" " + l.getName());
712     } else
713       buf.append(" arg" + var_index);
714
715     var_index++;
716     buf.append(", ");
717     index += consumed_chars; // update position
718 }
719
720       index++; // update position
721
722       // Read return type after `)'
723 type = signatureToString(signature.substring(index), chopit);
724
725     } catch(StringIndexOutOfBoundsException e) { // Should never occur
726 throw new ClassFormatError ("Invalid method signature: " + signature);
727     }
728
729     if(buf.length() > 1) // Tack off the extra ", "
730 buf.setLength(buf.length() - 2);
731
732     buf.append(")");
733
734     return access + ((access.length() > 0)? " " : "") + // May be an empty string
735 type + " " + name + buf.toString();
736   }
737
738   // Guess what this does
739 private static final int pow2(int n) {
740     return 1 << n;
741   }
742     
743   /**
744    * Replace all occurences of <em>old</em> in <em>str</em> with <em>new</em>.
745    *
746    * @param str String to permute
747    * @param old String to be replaced
748    * @param new Replacement string
749    * @return new String object
750    */
751   public static final String replace(String str, String old, String new_) {
752     int index, old_index;
753     StringBuffer buf = new StringBuffer ();
754
755     try {
756       if((index = str.indexOf(old)) != -1) { // `old' found in str
757 old_index = 0; // String start offset
758
759     // While we have something to replace
760 while((index = str.indexOf(old, old_index)) != -1) {
761       buf.append(str.substring(old_index, index)); // append prefix
762 buf.append(new_); // append replacement
763
764       old_index = index + old.length(); // Skip `old'.length chars
765 }
766
767     buf.append(str.substring(old_index)); // append rest of string
768 str = buf.toString();
769       }
770     } catch(StringIndexOutOfBoundsException e) { // Should not occur
771 System.err.println(e);
772     }
773
774     return str;
775   }
776
777   /**
778    * Converts signature to string with all class names compacted.
779    *
780    * @param signature to convert
781    * @return Human readable signature
782    */
783   public static final String signatureToString(String signature) {
784     return signatureToString(signature, true);
785   }
786
787   /**
788    * The field signature represents the value of an argument to a function or
789    * the value of a variable. It is a series of bytes generated by the
790    * following grammar:
791    *
792    * <PRE>
793    * <field_signature> ::= <field_type>
794    * <field_type> ::= <base_type>|<object_type>|<array_type>
795    * <base_type> ::= B|C|D|F|I|J|S|Z
796    * <object_type> ::= L<fullclassname>;
797    * <array_type> ::= [<field_type>
798    *
799    * The meaning of the base types is as follows:
800    * B byte signed byte
801    * C char character
802    * D double double precision IEEE float
803    * F float single precision IEEE float
804    * I int integer
805    * J long long integer
806    * L<fullclassname>; ... an object of the given class
807    * S short signed short
808    * Z boolean true or false
809    * [<field sig> ... array
810    * </PRE>
811    *
812    * This method converts this string into a Java type declaration such as
813    * `String[]' and throws a `ClassFormatError' when the parsed type is
814    * invalid.
815    *
816    * @param signature Class signature
817    * @param chopit Flag that determines whether chopping is executed or not
818    * @return Java type declaration
819    * @throws ClassFormatError
820    */
821   public static final String signatureToString(String signature,
822                            boolean chopit)
823   {
824     consumed_chars = 1; // This is the default, read just one char like `B'
825
826     try {
827       switch(signature.charAt(0)) {
828       case 'B' : return "byte";
829       case 'C' : return "char";
830       case 'D' : return "double";
831       case 'F' : return "float";
832       case 'I' : return "int";
833       case 'J' : return "long";
834
835       case 'L' : { // Full class name
836 int index = signature.indexOf(';'); // Look for closing `;'
837
838     if(index < 0)
839       throw new ClassFormatError ("Invalid signature: " + signature);
840     
841     consumed_chars = index + 1; // "Lblabla;" `L' and `;' are removed
842
843     return compactClassName(signature.substring(1, index), chopit);
844       }
845
846       case 'S' : return "short";
847       case 'Z' : return "boolean";
848
849       case '[' : { // Array declaration
850 int n;
851     StringBuffer buf, brackets;
852     String type;
853     char ch;
854     int consumed_chars; // Shadows global var
855
856     brackets = new StringBuffer (); // Accumulate []'s
857
858     // Count opening brackets and look for optional size argument
859 for(n=0; signature.charAt(n) == '['; n++)
860       brackets.append("[]");
861
862     consumed_chars = n; // Remember value
863
864     // The rest of the string denotes a `<field_type>'
865 type = signatureToString(signature.substring(n), chopit);
866     
867     Utility.consumed_chars += consumed_chars;
868     return type + brackets.toString();
869       }
870
871       case 'V' : return "void";
872
873       default : throw new ClassFormatError ("Invalid signature: `" +
874                         signature + "'");
875       }
876     } catch(StringIndexOutOfBoundsException e) { // Should never occur
877 throw new ClassFormatError ("Invalid signature: " + e + ":" + signature);
878     }
879   }
880
881   /** Parse Java type such as "char", or "java.lang.String[]" and return the
882    * signature in byte code format, e.g. "C" or "[Ljava/lang/String;" respectively.
883    *
884    * @param type Java type
885    * @return byte code signature
886    */
887   public static String getSignature(String type) {
888     StringBuffer buf = new StringBuffer ();
889     char[] chars = type.toCharArray();
890     boolean char_found = false, delim = false;
891     int index = -1;
892
893   loop:
894     for(int i=0; i < chars.length; i++) {
895       switch(chars[i]) {
896       case ' ': case '\t': case '\n': case '\r': case '\f':
897     if(char_found)
898       delim = true;
899     break;
900
901       case '[':
902     if(!char_found)
903       throw new RuntimeException ("Illegal type: " + type);
904
905     index = i;
906     break loop;
907
908       default:
909     char_found = true;
910     if(!delim)
911       buf.append(chars[i]);
912       }
913     }
914
915     int brackets = 0;
916
917     if(index > 0)
918       brackets = countBrackets(type.substring(index));
919
920     type = buf.toString();
921     buf.setLength(0);
922
923     for(int i=0; i < brackets; i++)
924       buf.append('[');
925
926     boolean found = false;
927
928     for(int i=Constants.T_BOOLEAN; (i <= Constants.T_VOID) && !found; i++) {
929       if(Constants.TYPE_NAMES[i].equals(type)) {
930     found = true;
931     buf.append(Constants.SHORT_TYPE_NAMES[i]);
932       }
933     }
934     
935     if(!found) // Class name
936 buf.append('L' + type.replace('.', '/') + ';');
937
938     return buf.toString();
939   }
940
941   private static int countBrackets(String brackets) {
942     char[] chars = brackets.toCharArray();
943     int count = 0;
944     boolean open = false;
945
946     for(int i=0; i<chars.length; i++) {
947       switch(chars[i]) {
948       case '[':
949     if(open)
950       throw new RuntimeException ("Illegally nested brackets:" + brackets);
951     open = true;
952     break;
953
954       case ']':
955     if(!open)
956       throw new RuntimeException ("Illegally nested brackets:" + brackets);
957     open = false;
958     count++;
959     break;
960
961       default:
962     // Don't care
963 }
964     }
965
966     if(open)
967       throw new RuntimeException ("Illegally nested brackets:" + brackets);
968
969     return count;
970   }
971
972   /**
973    * Return type of method signature as a byte value as defined in <em>Constants</em>
974    *
975    * @param signature in format described above
976    * @return type of method signature
977    * @see Constants
978    */
979   public static final byte typeOfMethodSignature(String signature)
980     throws ClassFormatError
981   {
982     int index;
983
984     try {
985       if(signature.charAt(0) != '(')
986     throw new ClassFormatError ("Invalid method signature: " + signature);
987
988       index = signature.lastIndexOf(')') + 1;
989       return typeOfSignature(signature.substring(index));
990     } catch(StringIndexOutOfBoundsException e) {
991       throw new ClassFormatError ("Invalid method signature: " + signature);
992     }
993   }
994
995   /**
996    * Return type of signature as a byte value as defined in <em>Constants</em>
997    *
998    * @param signature in format described above
999    * @return type of signature
1000   * @see Constants
1001   */
1002  public static final byte typeOfSignature(String signature)
1003    throws ClassFormatError
1004  {
1005    try {
1006      switch(signature.charAt(0)) {
1007      case 'B' : return Constants.T_BYTE;
1008      case 'C' : return Constants.T_CHAR;
1009      case 'D' : return Constants.T_DOUBLE;
1010      case 'F' : return Constants.T_FLOAT;
1011      case 'I' : return Constants.T_INT;
1012      case 'J' : return Constants.T_LONG;
1013      case 'L' : return Constants.T_REFERENCE;
1014      case '[' : return Constants.T_ARRAY;
1015      case 'V' : return Constants.T_VOID;
1016      case 'Z' : return Constants.T_BOOLEAN;
1017      case 'S' : return Constants.T_SHORT;
1018      default:
1019    throw new ClassFormatError ("Invalid method signature: " + signature);
1020      }
1021    } catch(StringIndexOutOfBoundsException e) {
1022      throw new ClassFormatError ("Invalid method signature: " + signature);
1023    }
1024  }
1025
1026  /** Map opcode names to opcode numbers. E.g., return Constants.ALOAD for "aload"
1027   */
1028  public static short searchOpcode(String name) {
1029    name = name.toLowerCase();
1030
1031    for(short i=0; i < Constants.OPCODE_NAMES.length; i++)
1032      if(Constants.OPCODE_NAMES[i].equals(name))
1033    return i;
1034    
1035    return -1;
1036  }
1037
1038  /**
1039   * Convert (signed) byte to (unsigned) short value, i.e., all negative
1040   * values become positive.
1041   */
1042  private static final short byteToShort(byte b) {
1043    return (b < 0)? (short)(256 + b) : (short)b;
1044  }
1045
1046  /** Convert bytes into hexidecimal string
1047   *
1048   * @return bytes as hexidecimal string, e.g. 00 FA 12 ...
1049   */
1050  public static final String toHexString(byte[] bytes) {
1051    StringBuffer buf = new StringBuffer ();
1052
1053    for(int i=0; i < bytes.length; i++) {
1054      short b = byteToShort(bytes[i]);
1055      String hex = Integer.toString(b, 0x10);
1056
1057      if(b < 0x10) // just one digit, prepend '0'
1058 buf.append('0');
1059
1060      buf.append(hex);
1061
1062      if(i < bytes.length - 1)
1063    buf.append(' ');
1064    }
1065
1066    return buf.toString();
1067  }
1068
1069  /**
1070   * Return a string for an integer justified left or right and filled up with
1071   * `fill' characters if necessary.
1072   *
1073   * @param i integer to format
1074   * @param length length of desired string
1075   * @param left_justify format left or right
1076   * @param fill fill character
1077   * @return formatted int
1078   */
1079  public static final String format(int i, int length, boolean left_justify, char fill) {
1080    return fillup(Integer.toString(i), length, left_justify, fill);
1081  }
1082
1083  /**
1084   * Fillup char with up to length characters with char `fill' and justify it left or right.
1085   *
1086   * @param str string to format
1087   * @param length length of desired string
1088   * @param left_justify format left or right
1089   * @param fill fill character
1090   * @return formatted string
1091   */
1092  public static final String fillup(String str, int length, boolean left_justify, char fill) {
1093    int len = length - str.length();
1094    char[] buf = new char[(len < 0)? 0 : len];
1095
1096    for(int j=0; j < buf.length; j++)
1097      buf[j] = fill;
1098
1099    if(left_justify)
1100      return str + new String (buf);
1101    else
1102      return new String (buf) + str;
1103  }
1104
1105  static final boolean equals(byte[] a, byte[] b) {
1106    int size;
1107
1108    if((size=a.length) != b.length)
1109      return false;
1110
1111    for(int i=0; i < size; i++)
1112      if(a[i] != b[i])
1113    return false;
1114
1115    return true;
1116  }
1117
1118  public static final void printArray(PrintStream out, Object [] obj) {
1119    out.println(printArray(obj, true));
1120  }
1121
1122  public static final void printArray(PrintWriter out, Object [] obj) {
1123    out.println(printArray(obj, true));
1124  }
1125
1126  public static final String printArray(Object [] obj) {
1127    return printArray(obj, true);
1128  }
1129
1130  public static final String printArray(Object [] obj, boolean braces) {
1131    if(obj == null)
1132      return null;
1133
1134    StringBuffer buf = new StringBuffer ();
1135    if(braces)
1136      buf.append('{');
1137
1138    for(int i=0; i < obj.length; i++) {
1139      if(obj[i] != null)
1140    buf.append(obj[i].toString());
1141      else
1142    buf.append("null");
1143
1144      if(i < obj.length - 1)
1145    buf.append(", ");
1146    }
1147
1148    if(braces)
1149      buf.append('}');
1150
1151    return buf.toString();
1152  }
1153
1154  /** @return true, if character is one of (a, ... z, A, ... Z, 0, ... 9, _)
1155   */
1156  public static boolean isJavaIdentifierPart(char ch) {
1157    return ((ch >= 'a') && (ch <= 'z')) ||
1158      ((ch >= 'A') && (ch <= 'Z')) ||
1159      ((ch >= '0') && (ch <= '9')) ||
1160      (ch == '_');
1161  }
1162
1163  /** Encode byte array it into Java identifier string, i.e., a string
1164   * that only contains the following characters: (a, ... z, A, ... Z,
1165   * 0, ... 9, _, $). The encoding algorithm itself is not too
1166   * clever: if the current byte's ASCII value already is a valid Java
1167   * identifier part, leave it as it is. Otherwise it writes the
1168   * escape character($) followed by <p><ul><li> the ASCII value as a
1169   * hexadecimal string, if the value is not in the range
1170   * 200..247</li> <li>a Java identifier char not used in a lowercase
1171   * hexadecimal string, if the value is in the range
1172   * 200..247</li><ul></p>
1173   *
1174   * <p>This operation inflates the original byte array by roughly 40-50%</p>
1175   *
1176   * @param bytes the byte array to convert
1177   * @param compress use gzip to minimize string
1178   */
1179  public static String encode(byte[] bytes, boolean compress) throws IOException {
1180    if(compress) {
1181      ByteArrayOutputStream baos = new ByteArrayOutputStream();
1182      GZIPOutputStream gos = new GZIPOutputStream(baos);
1183
1184      gos.write(bytes, 0, bytes.length);
1185      gos.close();
1186      baos.close();
1187
1188      bytes = baos.toByteArray();
1189    }
1190
1191    CharArrayWriter caw = new CharArrayWriter();
1192    JavaWriter jw = new JavaWriter(caw);
1193
1194    for(int i=0; i < bytes.length; i++) {
1195      int in = bytes[i] & 0x000000ff; // Normalize to unsigned
1196 jw.write(in);
1197    }
1198
1199    return caw.toString();
1200  }
1201
1202  /** Decode a string back to a byte array.
1203   *
1204   * @param bytes the byte array to convert
1205   * @param uncompress use gzip to uncompress the stream of bytes
1206   */
1207  public static byte[] decode(String s, boolean uncompress) throws IOException {
1208    char[] chars = s.toCharArray();
1209
1210    CharArrayReader car = new CharArrayReader(chars);
1211    JavaReader jr = new JavaReader(car);
1212
1213    ByteArrayOutputStream bos = new ByteArrayOutputStream();
1214
1215    int ch;
1216
1217    while((ch = jr.read()) >= 0) {
1218      bos.write(ch);
1219    }
1220
1221    bos.close();
1222    car.close();
1223    jr.close();
1224
1225    byte[] bytes = bos.toByteArray();
1226
1227    if(uncompress) {
1228      GZIPInputStream gis = new GZIPInputStream(new ByteArrayInputStream(bytes));
1229
1230      byte[] tmp = new byte[bytes.length * 3]; // Rough estimate
1231 int count = 0;
1232      int b;
1233
1234      while((b = gis.read()) >= 0)
1235    tmp[count++] = (byte)b;
1236
1237      bytes = new byte[count];
1238      System.arraycopy(tmp, 0, bytes, 0, count);
1239    }
1240
1241    return bytes;
1242  }
1243
1244  // A-Z, g-z, _, $
1245 private static final int FREE_CHARS = 48;
1246  private static int[] CHAR_MAP = new int[FREE_CHARS];
1247  private static int[] MAP_CHAR = new int[256]; // Reverse map
1248 private static final char ESCAPE_CHAR = '$';
1249
1250  static {
1251    int j = 0, k = 0;
1252    for(int i='A'; i <= 'Z'; i++) {
1253      CHAR_MAP[j] = i;
1254      MAP_CHAR[i] = j;
1255      j++;
1256    }
1257
1258    for(int i='g'; i <= 'z'; i++) {
1259      CHAR_MAP[j] = i;
1260      MAP_CHAR[i] = j;
1261      j++;
1262    }
1263
1264    CHAR_MAP[j] = '$';
1265    MAP_CHAR['$'] = j;
1266    j++;
1267
1268    CHAR_MAP[j] = '_';
1269    MAP_CHAR['_'] = j;
1270  }
1271
1272  /** Decode characters into bytes.
1273   * Used by <a HREF="Utility.html#decode(java.lang.String, boolean)">decode()</a>
1274   */
1275  private static class JavaReader extends FilterReader {
1276    public JavaReader(Reader in) {
1277      super(in);
1278    }
1279
1280    public int read() throws IOException {
1281      int b = in.read();
1282
1283      if(b != ESCAPE_CHAR) {
1284    return b;
1285      } else {
1286    int i = in.read();
1287
1288    if(i < 0)
1289      return -1;
1290
1291    if(((i >= '0') && (i <= '9')) || ((i >= 'a') && (i <= 'f'))) { // Normal escape
1292 int j = in.read();
1293
1294      if(j < 0)
1295        return -1;
1296
1297      char[] tmp = { (char)i, (char)j };
1298      int s = Integer.parseInt(new String (tmp), 16);
1299
1300      return s;
1301    } else { // Special escape
1302 return MAP_CHAR[i];
1303    }
1304      }
1305    }
1306
1307    public int read(char[] cbuf, int off, int len) throws IOException {
1308      for(int i=0; i < len; i++)
1309    cbuf[off + i] = (char)read();
1310
1311      return len;
1312    }
1313  }
1314
1315  /** Encode bytes into valid java identifier characters.
1316   * Used by <a HREF="Utility.html#encode(byte[], boolean)">encode()</a>
1317   */
1318  private static class JavaWriter extends FilterWriter {
1319    public JavaWriter(Writer out) {
1320      super(out);
1321    }
1322
1323    public void write(int b) throws IOException {
1324      if(isJavaIdentifierPart((char)b) && (b != ESCAPE_CHAR)) {
1325    out.write(b);
1326      } else {
1327    out.write(ESCAPE_CHAR); // Escape character
1328
1329    // Special escape
1330 if(b >= 0 && b < FREE_CHARS) {
1331      out.write(CHAR_MAP[b]);
1332    } else { // Normal escape
1333 char[] tmp = Integer.toHexString(b).toCharArray();
1334
1335      if(tmp.length == 1) {
1336        out.write('0');
1337        out.write(tmp[0]);
1338      } else {
1339        out.write(tmp[0]);
1340        out.write(tmp[1]);
1341      }
1342    }
1343      }
1344    }
1345
1346    public void write(char[] cbuf, int off, int len) throws IOException {
1347      for(int i=0; i < len; i++)
1348    write(cbuf[off + i]);
1349    }
1350
1351    public void write(String str, int off, int len) throws IOException {
1352      write(str.toCharArray(), off, len);
1353    }
1354  }
1355}
1356

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags