< prev index next >

src/jdk.jdeps/share/classes/com/sun/tools/classfile/ClassTranslator.java

Print this page




  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.classfile;
  27 
  28 import java.util.Map;
  29 
  30 import com.sun.tools.classfile.ConstantPool.CONSTANT_Class_info;
  31 import com.sun.tools.classfile.ConstantPool.CONSTANT_Double_info;
  32 import com.sun.tools.classfile.ConstantPool.CONSTANT_Fieldref_info;
  33 import com.sun.tools.classfile.ConstantPool.CONSTANT_Float_info;
  34 import com.sun.tools.classfile.ConstantPool.CONSTANT_Integer_info;
  35 import com.sun.tools.classfile.ConstantPool.CONSTANT_InterfaceMethodref_info;
  36 import com.sun.tools.classfile.ConstantPool.CONSTANT_InvokeDynamic_info;
  37 import com.sun.tools.classfile.ConstantPool.CONSTANT_Long_info;
  38 import com.sun.tools.classfile.ConstantPool.CONSTANT_MethodHandle_info;
  39 import com.sun.tools.classfile.ConstantPool.CONSTANT_MethodType_info;
  40 import com.sun.tools.classfile.ConstantPool.CONSTANT_Methodref_info;

  41 import com.sun.tools.classfile.ConstantPool.CONSTANT_NameAndType_info;

  42 import com.sun.tools.classfile.ConstantPool.CONSTANT_String_info;
  43 import com.sun.tools.classfile.ConstantPool.CONSTANT_Utf8_info;
  44 import com.sun.tools.classfile.ConstantPool.CPInfo;
  45 
  46 /**
  47  * Rewrites a class file using a map of translations.
  48  *
  49  *  <p><b>This is NOT part of any supported API.
  50  *  If you write code that depends on this, you do so at your own risk.
  51  *  This code and its internal interfaces are subject to change or
  52  *  deletion without notice.</b>
  53  */
  54 public class ClassTranslator
  55         implements ConstantPool.Visitor<ConstantPool.CPInfo,Map<Object,Object>> {
  56     /**
  57      * Create a new ClassFile from {@code cf}, such that for all entries
  58      * {@code k&nbsp;-\&gt;&nbsp;v} in {@code translations},
  59      * each occurrence of {@code k} in {@code cf} will be replaced by {@code v}.
  60      * in
  61      * @param cf the class file to be processed


 225         if (attribute2 == null) {
 226             attribute2 = attribute; // don't support translation within attributes yet
 227                                     // (what about Code attribute)
 228             translations.put(attribute, attribute2);
 229         }
 230         return attribute2;
 231     }
 232 
 233     private static <T> boolean equal(T[] a1, T[] a2) {
 234         if (a1 == null || a2 == null)
 235             return (a1 == a2);
 236         if (a1.length != a2.length)
 237             return false;
 238         for (int i = 0; i < a1.length; i++) {
 239             if (a1[i] != a2[i])
 240                 return false;
 241         }
 242         return true;
 243     }
 244 

 245     public CPInfo visitClass(CONSTANT_Class_info info, Map<Object, Object> translations) {
 246         CONSTANT_Class_info info2 = (CONSTANT_Class_info) translations.get(info);
 247         if (info2 == null) {
 248             ConstantPool cp2 = translate(info.cp, translations);
 249             if (cp2 == info.cp)
 250                 info2 = info;
 251             else
 252                 info2 = new CONSTANT_Class_info(cp2, info.name_index);
 253             translations.put(info, info2);
 254         }
 255         return info;
 256     }
 257 

 258     public CPInfo visitDouble(CONSTANT_Double_info info, Map<Object, Object> translations) {
 259         CONSTANT_Double_info info2 = (CONSTANT_Double_info) translations.get(info);
 260         if (info2 == null) {
 261             info2 = info;
 262             translations.put(info, info2);
 263         }
 264         return info;
 265     }
 266 

 267     public CPInfo visitFieldref(CONSTANT_Fieldref_info info, Map<Object, Object> translations) {
 268         CONSTANT_Fieldref_info info2 = (CONSTANT_Fieldref_info) translations.get(info);
 269         if (info2 == null) {
 270             ConstantPool cp2 = translate(info.cp, translations);
 271             if (cp2 == info.cp)
 272                 info2 = info;
 273             else
 274                 info2 = new CONSTANT_Fieldref_info(cp2, info.class_index, info.name_and_type_index);
 275             translations.put(info, info2);
 276         }
 277         return info;
 278     }
 279 

 280     public CPInfo visitFloat(CONSTANT_Float_info info, Map<Object, Object> translations) {
 281         CONSTANT_Float_info info2 = (CONSTANT_Float_info) translations.get(info);
 282         if (info2 == null) {
 283             info2 = info;
 284             translations.put(info, info2);
 285         }
 286         return info;
 287     }
 288 

 289     public CPInfo visitInteger(CONSTANT_Integer_info info, Map<Object, Object> translations) {
 290         CONSTANT_Integer_info info2 = (CONSTANT_Integer_info) translations.get(info);
 291         if (info2 == null) {
 292             info2 = info;
 293             translations.put(info, info2);
 294         }
 295         return info;
 296     }
 297 

 298     public CPInfo visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, Map<Object, Object> translations) {
 299         CONSTANT_InterfaceMethodref_info info2 = (CONSTANT_InterfaceMethodref_info) translations.get(info);
 300         if (info2 == null) {
 301             ConstantPool cp2 = translate(info.cp, translations);
 302             if (cp2 == info.cp)
 303                 info2 = info;
 304             else
 305                 info2 = new CONSTANT_InterfaceMethodref_info(cp2, info.class_index, info.name_and_type_index);
 306             translations.put(info, info2);
 307         }
 308         return info;
 309     }
 310 

 311     public CPInfo visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, Map<Object, Object> translations) {
 312         CONSTANT_InvokeDynamic_info info2 = (CONSTANT_InvokeDynamic_info) translations.get(info);
 313         if (info2 == null) {
 314             ConstantPool cp2 = translate(info.cp, translations);
 315             if (cp2 == info.cp) {
 316                 info2 = info;
 317             } else {
 318                 info2 = new CONSTANT_InvokeDynamic_info(cp2, info.bootstrap_method_attr_index, info.name_and_type_index);
 319             }
 320             translations.put(info, info2);
 321         }
 322         return info;
 323     }
 324 

 325     public CPInfo visitLong(CONSTANT_Long_info info, Map<Object, Object> translations) {
 326         CONSTANT_Long_info info2 = (CONSTANT_Long_info) translations.get(info);
 327         if (info2 == null) {
 328             info2 = info;
 329             translations.put(info, info2);
 330         }
 331         return info;
 332     }
 333 
 334     public CPInfo visitNameAndType(CONSTANT_NameAndType_info info, Map<Object, Object> translations) {
 335         CONSTANT_NameAndType_info info2 = (CONSTANT_NameAndType_info) translations.get(info);
 336         if (info2 == null) {
 337             ConstantPool cp2 = translate(info.cp, translations);
 338             if (cp2 == info.cp)
 339                 info2 = info;
 340             else
 341                 info2 = new CONSTANT_NameAndType_info(cp2, info.name_index, info.type_index);
 342             translations.put(info, info2);
 343         }
 344         return info;
 345     }
 346 
 347     public CPInfo visitMethodref(CONSTANT_Methodref_info info, Map<Object, Object> translations) {
 348         CONSTANT_Methodref_info info2 = (CONSTANT_Methodref_info) translations.get(info);
 349         if (info2 == null) {
 350             ConstantPool cp2 = translate(info.cp, translations);
 351             if (cp2 == info.cp)
 352                 info2 = info;
 353             else
 354                 info2 = new CONSTANT_Methodref_info(cp2, info.class_index, info.name_and_type_index);
 355             translations.put(info, info2);
 356         }
 357         return info;
 358     }
 359 

 360     public CPInfo visitMethodHandle(CONSTANT_MethodHandle_info info, Map<Object, Object> translations) {
 361         CONSTANT_MethodHandle_info info2 = (CONSTANT_MethodHandle_info) translations.get(info);
 362         if (info2 == null) {
 363             ConstantPool cp2 = translate(info.cp, translations);
 364             if (cp2 == info.cp) {
 365                 info2 = info;
 366             } else {
 367                 info2 = new CONSTANT_MethodHandle_info(cp2, info.reference_kind, info.reference_index);
 368             }
 369             translations.put(info, info2);
 370         }
 371         return info;
 372     }
 373 

 374     public CPInfo visitMethodType(CONSTANT_MethodType_info info, Map<Object, Object> translations) {
 375         CONSTANT_MethodType_info info2 = (CONSTANT_MethodType_info) translations.get(info);
 376         if (info2 == null) {
 377             ConstantPool cp2 = translate(info.cp, translations);
 378             if (cp2 == info.cp) {
 379                 info2 = info;
 380             } else {
 381                 info2 = new CONSTANT_MethodType_info(cp2, info.descriptor_index);
 382             }
 383             translations.put(info, info2);
 384         }
 385         return info;
 386     }
 387 











































 388     public CPInfo visitString(CONSTANT_String_info info, Map<Object, Object> translations) {
 389         CONSTANT_String_info info2 = (CONSTANT_String_info) translations.get(info);
 390         if (info2 == null) {
 391             ConstantPool cp2 = translate(info.cp, translations);
 392             if (cp2 == info.cp)
 393                 info2 = info;
 394             else
 395                 info2 = new CONSTANT_String_info(cp2, info.string_index);
 396             translations.put(info, info2);
 397         }
 398         return info;
 399     }
 400 

 401     public CPInfo visitUtf8(CONSTANT_Utf8_info info, Map<Object, Object> translations) {
 402         CONSTANT_Utf8_info info2 = (CONSTANT_Utf8_info) translations.get(info);
 403         if (info2 == null) {
 404             info2 = info;
 405             translations.put(info, info2);
 406         }
 407         return info;
 408     }
 409 
 410 }


  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.classfile;
  27 
  28 import java.util.Map;
  29 
  30 import com.sun.tools.classfile.ConstantPool.CONSTANT_Class_info;
  31 import com.sun.tools.classfile.ConstantPool.CONSTANT_Double_info;
  32 import com.sun.tools.classfile.ConstantPool.CONSTANT_Fieldref_info;
  33 import com.sun.tools.classfile.ConstantPool.CONSTANT_Float_info;
  34 import com.sun.tools.classfile.ConstantPool.CONSTANT_Integer_info;
  35 import com.sun.tools.classfile.ConstantPool.CONSTANT_InterfaceMethodref_info;
  36 import com.sun.tools.classfile.ConstantPool.CONSTANT_InvokeDynamic_info;
  37 import com.sun.tools.classfile.ConstantPool.CONSTANT_Long_info;
  38 import com.sun.tools.classfile.ConstantPool.CONSTANT_MethodHandle_info;
  39 import com.sun.tools.classfile.ConstantPool.CONSTANT_MethodType_info;
  40 import com.sun.tools.classfile.ConstantPool.CONSTANT_Methodref_info;
  41 import com.sun.tools.classfile.ConstantPool.CONSTANT_Module_info;
  42 import com.sun.tools.classfile.ConstantPool.CONSTANT_NameAndType_info;
  43 import com.sun.tools.classfile.ConstantPool.CONSTANT_Package_info;
  44 import com.sun.tools.classfile.ConstantPool.CONSTANT_String_info;
  45 import com.sun.tools.classfile.ConstantPool.CONSTANT_Utf8_info;
  46 import com.sun.tools.classfile.ConstantPool.CPInfo;
  47 
  48 /**
  49  * Rewrites a class file using a map of translations.
  50  *
  51  *  <p><b>This is NOT part of any supported API.
  52  *  If you write code that depends on this, you do so at your own risk.
  53  *  This code and its internal interfaces are subject to change or
  54  *  deletion without notice.</b>
  55  */
  56 public class ClassTranslator
  57         implements ConstantPool.Visitor<ConstantPool.CPInfo,Map<Object,Object>> {
  58     /**
  59      * Create a new ClassFile from {@code cf}, such that for all entries
  60      * {@code k&nbsp;-\&gt;&nbsp;v} in {@code translations},
  61      * each occurrence of {@code k} in {@code cf} will be replaced by {@code v}.
  62      * in
  63      * @param cf the class file to be processed


 227         if (attribute2 == null) {
 228             attribute2 = attribute; // don't support translation within attributes yet
 229                                     // (what about Code attribute)
 230             translations.put(attribute, attribute2);
 231         }
 232         return attribute2;
 233     }
 234 
 235     private static <T> boolean equal(T[] a1, T[] a2) {
 236         if (a1 == null || a2 == null)
 237             return (a1 == a2);
 238         if (a1.length != a2.length)
 239             return false;
 240         for (int i = 0; i < a1.length; i++) {
 241             if (a1[i] != a2[i])
 242                 return false;
 243         }
 244         return true;
 245     }
 246 
 247     @Override
 248     public CPInfo visitClass(CONSTANT_Class_info info, Map<Object, Object> translations) {
 249         CONSTANT_Class_info info2 = (CONSTANT_Class_info) translations.get(info);
 250         if (info2 == null) {
 251             ConstantPool cp2 = translate(info.cp, translations);
 252             if (cp2 == info.cp)
 253                 info2 = info;
 254             else
 255                 info2 = new CONSTANT_Class_info(cp2, info.name_index);
 256             translations.put(info, info2);
 257         }
 258         return info;
 259     }
 260 
 261     @Override
 262     public CPInfo visitDouble(CONSTANT_Double_info info, Map<Object, Object> translations) {
 263         CONSTANT_Double_info info2 = (CONSTANT_Double_info) translations.get(info);
 264         if (info2 == null) {
 265             info2 = info;
 266             translations.put(info, info2);
 267         }
 268         return info;
 269     }
 270 
 271     @Override
 272     public CPInfo visitFieldref(CONSTANT_Fieldref_info info, Map<Object, Object> translations) {
 273         CONSTANT_Fieldref_info info2 = (CONSTANT_Fieldref_info) translations.get(info);
 274         if (info2 == null) {
 275             ConstantPool cp2 = translate(info.cp, translations);
 276             if (cp2 == info.cp)
 277                 info2 = info;
 278             else
 279                 info2 = new CONSTANT_Fieldref_info(cp2, info.class_index, info.name_and_type_index);
 280             translations.put(info, info2);
 281         }
 282         return info;
 283     }
 284 
 285     @Override
 286     public CPInfo visitFloat(CONSTANT_Float_info info, Map<Object, Object> translations) {
 287         CONSTANT_Float_info info2 = (CONSTANT_Float_info) translations.get(info);
 288         if (info2 == null) {
 289             info2 = info;
 290             translations.put(info, info2);
 291         }
 292         return info;
 293     }
 294 
 295     @Override
 296     public CPInfo visitInteger(CONSTANT_Integer_info info, Map<Object, Object> translations) {
 297         CONSTANT_Integer_info info2 = (CONSTANT_Integer_info) translations.get(info);
 298         if (info2 == null) {
 299             info2 = info;
 300             translations.put(info, info2);
 301         }
 302         return info;
 303     }
 304 
 305     @Override
 306     public CPInfo visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, Map<Object, Object> translations) {
 307         CONSTANT_InterfaceMethodref_info info2 = (CONSTANT_InterfaceMethodref_info) translations.get(info);
 308         if (info2 == null) {
 309             ConstantPool cp2 = translate(info.cp, translations);
 310             if (cp2 == info.cp)
 311                 info2 = info;
 312             else
 313                 info2 = new CONSTANT_InterfaceMethodref_info(cp2, info.class_index, info.name_and_type_index);
 314             translations.put(info, info2);
 315         }
 316         return info;
 317     }
 318 
 319     @Override
 320     public CPInfo visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, Map<Object, Object> translations) {
 321         CONSTANT_InvokeDynamic_info info2 = (CONSTANT_InvokeDynamic_info) translations.get(info);
 322         if (info2 == null) {
 323             ConstantPool cp2 = translate(info.cp, translations);
 324             if (cp2 == info.cp) {
 325                 info2 = info;
 326             } else {
 327                 info2 = new CONSTANT_InvokeDynamic_info(cp2, info.bootstrap_method_attr_index, info.name_and_type_index);
 328             }
 329             translations.put(info, info2);
 330         }
 331         return info;
 332     }
 333 
 334     @Override
 335     public CPInfo visitLong(CONSTANT_Long_info info, Map<Object, Object> translations) {
 336         CONSTANT_Long_info info2 = (CONSTANT_Long_info) translations.get(info);
 337         if (info2 == null) {
 338             info2 = info;
 339             translations.put(info, info2);
 340         }
 341         return info;
 342     }
 343 
 344     @Override












 345     public CPInfo visitMethodref(CONSTANT_Methodref_info info, Map<Object, Object> translations) {
 346         CONSTANT_Methodref_info info2 = (CONSTANT_Methodref_info) translations.get(info);
 347         if (info2 == null) {
 348             ConstantPool cp2 = translate(info.cp, translations);
 349             if (cp2 == info.cp)
 350                 info2 = info;
 351             else
 352                 info2 = new CONSTANT_Methodref_info(cp2, info.class_index, info.name_and_type_index);
 353             translations.put(info, info2);
 354         }
 355         return info;
 356     }
 357 
 358     @Override
 359     public CPInfo visitMethodHandle(CONSTANT_MethodHandle_info info, Map<Object, Object> translations) {
 360         CONSTANT_MethodHandle_info info2 = (CONSTANT_MethodHandle_info) translations.get(info);
 361         if (info2 == null) {
 362             ConstantPool cp2 = translate(info.cp, translations);
 363             if (cp2 == info.cp) {
 364                 info2 = info;
 365             } else {
 366                 info2 = new CONSTANT_MethodHandle_info(cp2, info.reference_kind, info.reference_index);
 367             }
 368             translations.put(info, info2);
 369         }
 370         return info;
 371     }
 372 
 373     @Override
 374     public CPInfo visitMethodType(CONSTANT_MethodType_info info, Map<Object, Object> translations) {
 375         CONSTANT_MethodType_info info2 = (CONSTANT_MethodType_info) translations.get(info);
 376         if (info2 == null) {
 377             ConstantPool cp2 = translate(info.cp, translations);
 378             if (cp2 == info.cp) {
 379                 info2 = info;
 380             } else {
 381                 info2 = new CONSTANT_MethodType_info(cp2, info.descriptor_index);
 382             }
 383             translations.put(info, info2);
 384         }
 385         return info;
 386     }
 387 
 388     @Override
 389     public CPInfo visitModule(CONSTANT_Module_info info, Map<Object, Object> translations) {
 390         CONSTANT_Module_info info2 = (CONSTANT_Module_info) translations.get(info);
 391         if (info2 == null) {
 392             ConstantPool cp2 = translate(info.cp, translations);
 393             if (cp2 == info.cp)
 394                 info2 = info;
 395             else
 396                 info2 = new CONSTANT_Module_info(cp2, info.name_index);
 397             translations.put(info, info2);
 398         }
 399         return info;
 400     }
 401 
 402     @Override
 403     public CPInfo visitNameAndType(CONSTANT_NameAndType_info info, Map<Object, Object> translations) {
 404         CONSTANT_NameAndType_info info2 = (CONSTANT_NameAndType_info) translations.get(info);
 405         if (info2 == null) {
 406             ConstantPool cp2 = translate(info.cp, translations);
 407             if (cp2 == info.cp)
 408                 info2 = info;
 409             else
 410                 info2 = new CONSTANT_NameAndType_info(cp2, info.name_index, info.type_index);
 411             translations.put(info, info2);
 412         }
 413         return info;
 414     }
 415 
 416     @Override
 417     public CPInfo visitPackage(CONSTANT_Package_info info, Map<Object, Object> translations) {
 418         CONSTANT_Package_info info2 = (CONSTANT_Package_info) translations.get(info);
 419         if (info2 == null) {
 420             ConstantPool cp2 = translate(info.cp, translations);
 421             if (cp2 == info.cp)
 422                 info2 = info;
 423             else
 424                 info2 = new CONSTANT_Package_info(cp2, info.name_index);
 425             translations.put(info, info2);
 426         }
 427         return info;
 428     }
 429 
 430     @Override
 431     public CPInfo visitString(CONSTANT_String_info info, Map<Object, Object> translations) {
 432         CONSTANT_String_info info2 = (CONSTANT_String_info) translations.get(info);
 433         if (info2 == null) {
 434             ConstantPool cp2 = translate(info.cp, translations);
 435             if (cp2 == info.cp)
 436                 info2 = info;
 437             else
 438                 info2 = new CONSTANT_String_info(cp2, info.string_index);
 439             translations.put(info, info2);
 440         }
 441         return info;
 442     }
 443 
 444     @Override
 445     public CPInfo visitUtf8(CONSTANT_Utf8_info info, Map<Object, Object> translations) {
 446         CONSTANT_Utf8_info info2 = (CONSTANT_Utf8_info) translations.get(info);
 447         if (info2 == null) {
 448             info2 = info;
 449             translations.put(info, info2);
 450         }
 451         return info;
 452     }
 453 
 454 }
< prev index next >