    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one
    003 * or more contributor license agreements.  See the NOTICE file
    004 * distributed with this work for additional information
    005 * regarding copyright ownership.  The ASF licenses this file
    006 * to you under the Apache License, Version 2.0 (the
    007 * "License"); you may not use this file except in compliance
    008 * with the License.  You may obtain a copy of the License at
    009 *
    010 *   https://www.apache.org/licenses/LICENSE-2.0
    011 *
    012 * Unless required by applicable law or agreed to in writing,
    013 * software distributed under the License is distributed on an
    014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    015 * KIND, either express or implied.  See the License for the
    016 * specific language governing permissions and limitations
    017 * under the License.
    018 */
    019package org.apache.bcel.generic;
    020
    021/**
    022 * Interface implementing the Visitor pattern programming style. I.e., a class that implements this interface can handle
    023 * all types of instructions with the properly typed methods just by calling the accept() method.
    024 */
    025public interface Visitor {
    026
    027    /**
    028     * Visits an AALOAD instruction.
    029     *
    030     * @param obj the instruction.
    031     */
    032    void visitAALOAD(AALOAD obj);
    033
    034    /**
    035     * Visits an AASTORE instruction.
    036     *
    037     * @param obj the instruction.
    038     */
    039    void visitAASTORE(AASTORE obj);
    040
    041    /**
    042     * Visits an ACONST_NULL instruction.
    043     *
    044     * @param obj the instruction.
    045     */
    046    void visitACONST_NULL(ACONST_NULL obj);
    047
    048    /**
    049     * Visits an AllocationInstruction.
    050     *
    051     * @param obj the instruction.
    052     */
    053    void visitAllocationInstruction(AllocationInstruction obj);
    054
    055    /**
    056     * Visits an ALOAD instruction.
    057     *
    058     * @param obj the instruction.
    059     */
    060    void visitALOAD(ALOAD obj);
    061
    062    /**
    063     * Visits an ANEWARRAY instruction.
    064     *
    065     * @param obj the instruction.
    066     */
    067    void visitANEWARRAY(ANEWARRAY obj);
    068
    069    /**
    070     * Visits an ARETURN instruction.
    071     *
    072     * @param obj the instruction.
    073     */
    074    void visitARETURN(ARETURN obj);
    075
    076    /**
    077     * Visits an ArithmeticInstruction.
    078     *
    079     * @param obj the instruction.
    080     */
    081    void visitArithmeticInstruction(ArithmeticInstruction obj);
    082
    083    /**
    084     * Visits an ArrayInstruction.
    085     *
    086     * @param obj the instruction.
    087     */
    088    void visitArrayInstruction(ArrayInstruction obj);
    089
    090    /**
    091     * Visits an ARRAYLENGTH instruction.
    092     *
    093     * @param obj the instruction.
    094     */
    095    void visitARRAYLENGTH(ARRAYLENGTH obj);
    096
    097    /**
    098     * Visits an ASTORE instruction.
    099     *
    100     * @param obj the instruction.
    101     */
    102    void visitASTORE(ASTORE obj);
    103
    104    /**
    105     * Visits an ATHROW instruction.
    106     *
    107     * @param obj the instruction.
    108     */
    109    void visitATHROW(ATHROW obj);
    110
    111    /**
    112     * Visits a BALOAD instruction.
    113     *
    114     * @param obj the instruction.
    115     */
    116    void visitBALOAD(BALOAD obj);
    117
    118    /**
    119     * Visits a BASTORE instruction.
    120     *
    121     * @param obj the instruction.
    122     */
    123    void visitBASTORE(BASTORE obj);
    124
    125    /**
    126     * Visits a BIPUSH instruction.
    127     *
    128     * @param obj the instruction.
    129     */
    130    void visitBIPUSH(BIPUSH obj);
    131
    132    /**
    133     * Visits a BranchInstruction.
    134     *
    135     * @param obj the instruction.
    136     */
    137    void visitBranchInstruction(BranchInstruction obj);
    138
    139    /**
    140     * Visits a BREAKPOINT instruction.
    141     *
    142     * @param obj the instruction.
    143     */
    144    void visitBREAKPOINT(BREAKPOINT obj);
    145
    146    /**
    147     * Visits a CALOAD instruction.
    148     *
    149     * @param obj the instruction.
    150     */
    151    void visitCALOAD(CALOAD obj);
    152
    153    /**
    154     * Visits a CASTORE instruction.
    155     *
    156     * @param obj the instruction.
    157     */
    158    void visitCASTORE(CASTORE obj);
    159
    160    /**
    161     * Visits a CHECKCAST instruction.
    162     *
    163     * @param obj the instruction.
    164     */
    165    void visitCHECKCAST(CHECKCAST obj);
    166
    167    /**
    168     * Visits a ConstantPushInstruction.
    169     *
    170     * @param obj the instruction.
    171     */
    172    void visitConstantPushInstruction(ConstantPushInstruction obj);
    173
    174    /**
    175     * Visits a ConversionInstruction.
    176     *
    177     * @param obj the instruction.
    178     */
    179    void visitConversionInstruction(ConversionInstruction obj);
    180
    181    /**
    182     * Visits a CPInstruction.
    183     *
    184     * @param obj the instruction.
    185     */
    186    void visitCPInstruction(CPInstruction obj);
    187
    188    /**
    189     * Visits a D2F instruction.
    190     *
    191     * @param obj the instruction.
    192     */
    193    void visitD2F(D2F obj);
    194
    195    /**
    196     * Visits a D2I instruction.
    197     *
    198     * @param obj the instruction.
    199     */
    200    void visitD2I(D2I obj);
    201
    202    /**
    203     * Visits a D2L instruction.
    204     *
    205     * @param obj the instruction.
    206     */
    207    void visitD2L(D2L obj);
    208
    209    /**
    210     * Visits a DADD instruction.
    211     *
    212     * @param obj the instruction.
    213     */
    214    void visitDADD(DADD obj);
    215
    216    /**
    217     * Visits a DALOAD instruction.
    218     *
    219     * @param obj the instruction.
    220     */
    221    void visitDALOAD(DALOAD obj);
    222
    223    /**
    224     * Visits a DASTORE instruction.
    225     *
    226     * @param obj the instruction.
    227     */
    228    void visitDASTORE(DASTORE obj);
    229
    230    /**
    231     * Visits a DCMPG instruction.
    232     *
    233     * @param obj the instruction.
    234     */
    235    void visitDCMPG(DCMPG obj);
    236
    237    /**
    238     * Visits a DCMPL instruction.
    239     *
    240     * @param obj the instruction.
    241     */
    242    void visitDCMPL(DCMPL obj);
    243
    244    /**
    245     * Visits a DCONST instruction.
    246     *
    247     * @param obj the instruction.
    248     */
    249    void visitDCONST(DCONST obj);
    250
    251    /**
    252     * Visits a DDIV instruction.
    253     *
    254     * @param obj the instruction.
    255     */
    256    void visitDDIV(DDIV obj);
    257
    258    /**
    259     * Visits a DLOAD instruction.
    260     *
    261     * @param obj the instruction.
    262     */
    263    void visitDLOAD(DLOAD obj);
    264
    265    /**
    266     * Visits a DMUL instruction.
    267     *
    268     * @param obj the instruction.
    269     */
    270    void visitDMUL(DMUL obj);
    271
    272    /**
    273     * Visits a DNEG instruction.
    274     *
    275     * @param obj the instruction.
    276     */
    277    void visitDNEG(DNEG obj);
    278
    279    /**
    280     * Visits a DREM instruction.
    281     *
    282     * @param obj the instruction.
    283     */
    284    void visitDREM(DREM obj);
    285
    286    /**
    287     * Visits a DRETURN instruction.
    288     *
    289     * @param obj the instruction.
    290     */
    291    void visitDRETURN(DRETURN obj);
    292
    293    /**
    294     * Visits a DSTORE instruction.
    295     *
    296     * @param obj the instruction.
    297     */
    298    void visitDSTORE(DSTORE obj);
    299
    300    /**
    301     * Visits a DSUB instruction.
    302     *
    303     * @param obj the instruction.
    304     */
    305    void visitDSUB(DSUB obj);
    306
    307    /**
    308     * Visits a DUP instruction.
    309     *
    310     * @param obj the instruction.
    311     */
    312    void visitDUP(DUP obj);
    313
    314    /**
    315     * Visits a DUP_X1 instruction.
    316     *
    317     * @param obj the instruction.
    318     */
    319    void visitDUP_X1(DUP_X1 obj);
    320
    321    /**
    322     * Visits a DUP_X2 instruction.
    323     *
    324     * @param obj the instruction.
    325     */
    326    void visitDUP_X2(DUP_X2 obj);
    327
    328    /**
    329     * Visits a DUP2 instruction.
    330     *
    331     * @param obj the instruction.
    332     */
    333    void visitDUP2(DUP2 obj);
    334
    335    /**
    336     * Visits a DUP2_X1 instruction.
    337     *
    338     * @param obj the instruction.
    339     */
    340    void visitDUP2_X1(DUP2_X1 obj);
    341
    342    /**
    343     * Visits a DUP2_X2 instruction.
    344     *
    345     * @param obj the instruction.
    346     */
    347    void visitDUP2_X2(DUP2_X2 obj);
    348
    349    /**
    350     * Visits an ExceptionThrower.
    351     *
    352     * @param obj the instruction.
    353     */
    354    void visitExceptionThrower(ExceptionThrower obj);
    355
    356    /**
    357     * Visits an F2D instruction.
    358     *
    359     * @param obj the instruction.
    360     */
    361    void visitF2D(F2D obj);
    362
    363    /**
    364     * Visits an F2I instruction.
    365     *
    366     * @param obj the instruction.
    367     */
    368    void visitF2I(F2I obj);
    369
    370    /**
    371     * Visits an F2L instruction.
    372     *
    373     * @param obj the instruction.
    374     */
    375    void visitF2L(F2L obj);
    376
    377    /**
    378     * Visits an FADD instruction.
    379     *
    380     * @param obj the instruction.
    381     */
    382    void visitFADD(FADD obj);
    383
    384    /**
    385     * Visits an FALOAD instruction.
    386     *
    387     * @param obj the instruction.
    388     */
    389    void visitFALOAD(FALOAD obj);
    390
    391    /**
    392     * Visits an FASTORE instruction.
    393     *
    394     * @param obj the instruction.
    395     */
    396    void visitFASTORE(FASTORE obj);
    397
    398    /**
    399     * Visits an FCMPG instruction.
    400     *
    401     * @param obj the instruction.
    402     */
    403    void visitFCMPG(FCMPG obj);
    404
    405    /**
    406     * Visits an FCMPL instruction.
    407     *
    408     * @param obj the instruction.
    409     */
    410    void visitFCMPL(FCMPL obj);
    411
    412    /**
    413     * Visits an FCONST instruction.
    414     *
    415     * @param obj the instruction.
    416     */
    417    void visitFCONST(FCONST obj);
    418
    419    /**
    420     * Visits an FDIV instruction.
    421     *
    422     * @param obj the instruction.
    423     */
    424    void visitFDIV(FDIV obj);
    425
    426    /**
    427     * Visits a FieldInstruction.
    428     *
    429     * @param obj the instruction.
    430     */
    431    void visitFieldInstruction(FieldInstruction obj);
    432
    433    /**
    434     * Visits a FieldOrMethod.
    435     *
    436     * @param obj the instruction.
    437     */
    438    void visitFieldOrMethod(FieldOrMethod obj);
    439
    440    /**
    441     * Visits an FLOAD instruction.
    442     *
    443     * @param obj the instruction.
    444     */
    445    void visitFLOAD(FLOAD obj);
    446
    447    /**
    448     * Visits an FMUL instruction.
    449     *
    450     * @param obj the instruction.
    451     */
    452    void visitFMUL(FMUL obj);
    453
    454    /**
    455     * Visits an FNEG instruction.
    456     *
    457     * @param obj the instruction.
    458     */
    459    void visitFNEG(FNEG obj);
    460
    461    /**
    462     * Visits an FREM instruction.
    463     *
    464     * @param obj the instruction.
    465     */
    466    void visitFREM(FREM obj);
    467
    468    /**
    469     * Visits an FRETURN instruction.
    470     *
    471     * @param obj the instruction.
    472     */
    473    void visitFRETURN(FRETURN obj);
    474
    475    /**
    476     * Visits an FSTORE instruction.
    477     *
    478     * @param obj the instruction.
    479     */
    480    void visitFSTORE(FSTORE obj);
    481
    482    /**
    483     * Visits an FSUB instruction.
    484     *
    485     * @param obj the instruction.
    486     */
    487    void visitFSUB(FSUB obj);
    488
    489    /**
    490     * Visits a GETFIELD instruction.
    491     *
    492     * @param obj the instruction.
    493     */
    494    void visitGETFIELD(GETFIELD obj);
    495
    496    /**
    497     * Visits a GETSTATIC instruction.
    498     *
    499     * @param obj the instruction.
    500     */
    501    void visitGETSTATIC(GETSTATIC obj);
    502
    503    /**
    504     * Visits a GOTO instruction.
    505     *
    506     * @param obj the instruction.
    507     */
    508    void visitGOTO(GOTO obj);
    509
    510    /**
    511     * Visits a GOTO_W instruction.
    512     *
    513     * @param obj the instruction.
    514     */
    515    void visitGOTO_W(GOTO_W obj);
    516
    517    /**
    518     * Visits a GotoInstruction.
    519     *
    520     * @param obj the instruction.
    521     */
    522    void visitGotoInstruction(GotoInstruction obj);
    523
    524    /**
    525     * Visits an I2B instruction.
    526     *
    527     * @param obj the instruction.
    528     */
    529    void visitI2B(I2B obj);
    530
    531    /**
    532     * Visits an I2C instruction.
    533     *
    534     * @param obj the instruction.
    535     */
    536    void visitI2C(I2C obj);
    537
    538    /**
    539     * Visits an I2D instruction.
    540     *
    541     * @param obj the instruction.
    542     */
    543    void visitI2D(I2D obj);
    544
    545    /**
    546     * Visits an I2F instruction.
    547     *
    548     * @param obj the instruction.
    549     */
    550    void visitI2F(I2F obj);
    551
    552    /**
    553     * Visits an I2L instruction.
    554     *
    555     * @param obj the instruction.
    556     */
    557    void visitI2L(I2L obj);
    558
    559    /**
    560     * Visits an I2S instruction.
    561     *
    562     * @param obj the instruction.
    563     */
    564    void visitI2S(I2S obj);
    565
    566    /**
    567     * Visits an IADD instruction.
    568     *
    569     * @param obj the instruction.
    570     */
    571    void visitIADD(IADD obj);
    572
    573    /**
    574     * Visits an IALOAD instruction.
    575     *
    576     * @param obj the instruction.
    577     */
    578    void visitIALOAD(IALOAD obj);
    579
    580    /**
    581     * Visits an IAND instruction.
    582     *
    583     * @param obj the instruction.
    584     */
    585    void visitIAND(IAND obj);
    586
    587    /**
    588     * Visits an IASTORE instruction.
    589     *
    590     * @param obj the instruction.
    591     */
    592    void visitIASTORE(IASTORE obj);
    593
    594    /**
    595     * Visits an ICONST instruction.
    596     *
    597     * @param obj the instruction.
    598     */
    599    void visitICONST(ICONST obj);
    600
    601    /**
    602     * Visits an IDIV instruction.
    603     *
    604     * @param obj the instruction.
    605     */
    606    void visitIDIV(IDIV obj);
    607
    608    /**
    609     * Visits an IF_ACMPEQ instruction.
    610     *
    611     * @param obj the instruction.
    612     */
    613    void visitIF_ACMPEQ(IF_ACMPEQ obj);
    614
    615    /**
    616     * Visits an IF_ACMPNE instruction.
    617     *
    618     * @param obj the instruction.
    619     */
    620    void visitIF_ACMPNE(IF_ACMPNE obj);
    621
    622    /**
    623     * Visits an IF_ICMPEQ instruction.
    624     *
    625     * @param obj the instruction.
    626     */
    627    void visitIF_ICMPEQ(IF_ICMPEQ obj);
    628
    629    /**
    630     * Visits an IF_ICMPGE instruction.
    631     *
    632     * @param obj the instruction.
    633     */
    634    void visitIF_ICMPGE(IF_ICMPGE obj);
    635
    636    /**
    637     * Visits an IF_ICMPGT instruction.
    638     *
    639     * @param obj the instruction.
    640     */
    641    void visitIF_ICMPGT(IF_ICMPGT obj);
    642
    643    /**
    644     * Visits an IF_ICMPLE instruction.
    645     *
    646     * @param obj the instruction.
    647     */
    648    void visitIF_ICMPLE(IF_ICMPLE obj);
    649
    650    /**
    651     * Visits an IF_ICMPLT instruction.
    652     *
    653     * @param obj the instruction.
    654     */
    655    void visitIF_ICMPLT(IF_ICMPLT obj);
    656
    657    /**
    658     * Visits an IF_ICMPNE instruction.
    659     *
    660     * @param obj the instruction.
    661     */
    662    void visitIF_ICMPNE(IF_ICMPNE obj);
    663
    664    /**
    665     * Visits an IFEQ instruction.
    666     *
    667     * @param obj the instruction.
    668     */
    669    void visitIFEQ(IFEQ obj);
    670
    671    /**
    672     * Visits an IFGE instruction.
    673     *
    674     * @param obj the instruction.
    675     */
    676    void visitIFGE(IFGE obj);
    677
    678    /**
    679     * Visits an IFGT instruction.
    680     *
    681     * @param obj the instruction.
    682     */
    683    void visitIFGT(IFGT obj);
    684
    685    /**
    686     * Visits an IfInstruction.
    687     *
    688     * @param obj the instruction.
    689     */
    690    void visitIfInstruction(IfInstruction obj);
    691
    692    /**
    693     * Visits an IFLE instruction.
    694     *
    695     * @param obj the instruction.
    696     */
    697    void visitIFLE(IFLE obj);
    698
    699    /**
    700     * Visits an IFLT instruction.
    701     *
    702     * @param obj the instruction.
    703     */
    704    void visitIFLT(IFLT obj);
    705
    706    /**
    707     * Visits an IFNE instruction.
    708     *
    709     * @param obj the instruction.
    710     */
    711    void visitIFNE(IFNE obj);
    712
    713    /**
    714     * Visits an IFNONNULL instruction.
    715     *
    716     * @param obj the instruction.
    717     */
    718    void visitIFNONNULL(IFNONNULL obj);
    719
    720    /**
    721     * Visits an IFNULL instruction.
    722     *
    723     * @param obj the instruction.
    724     */
    725    void visitIFNULL(IFNULL obj);
    726
    727    /**
    728     * Visits an IINC instruction.
    729     *
    730     * @param obj the instruction.
    731     */
    732    void visitIINC(IINC obj);
    733
    734    /**
    735     * Visits an ILOAD instruction.
    736     *
    737     * @param obj the instruction.
    738     */
    739    void visitILOAD(ILOAD obj);
    740
    741    /**
    742     * Visits an IMPDEP1 instruction.
    743     *
    744     * @param obj the instruction.
    745     */
    746    void visitIMPDEP1(IMPDEP1 obj);
    747
    748    /**
    749     * Visits an IMPDEP2 instruction.
    750     *
    751     * @param obj the instruction.
    752     */
    753    void visitIMPDEP2(IMPDEP2 obj);
    754
    755    /**
    756     * Visits an IMUL instruction.
    757     *
    758     * @param obj the instruction.
    759     */
    760    void visitIMUL(IMUL obj);
    761
    762    /**
    763     * Visits an INEG instruction.
    764     *
    765     * @param obj the instruction.
    766     */
    767    void visitINEG(INEG obj);
    768
    769    /**
    770     * Visits an INSTANCEOF instruction.
    771     *
    772     * @param obj the instruction.
    773     */
    774    void visitINSTANCEOF(INSTANCEOF obj);
    775
    776    /**
    777     * Visits an INVOKEDYNAMIC instruction.
    778     *
    779     * @param obj the instruction.
    780     * @since 6.0
    781     */
    782    void visitINVOKEDYNAMIC(INVOKEDYNAMIC obj);
    783
    784    /**
    785     * Visits an InvokeInstruction.
    786     *
    787     * @param obj the instruction.
    788     */
    789    void visitInvokeInstruction(InvokeInstruction obj);
    790
    791    /**
    792     * Visits an INVOKEINTERFACE instruction.
    793     *
    794     * @param obj the instruction.
    795     */
    796    void visitINVOKEINTERFACE(INVOKEINTERFACE obj);
    797
    798    /**
    799     * Visits an INVOKESPECIAL instruction.
    800     *
    801     * @param obj the instruction.
    802     */
    803    void visitINVOKESPECIAL(INVOKESPECIAL obj);
    804
    805    /**
    806     * Visits an INVOKESTATIC instruction.
    807     *
    808     * @param obj the instruction.
    809     */
    810    void visitINVOKESTATIC(INVOKESTATIC obj);
    811
    812    /**
    813     * Visits an INVOKEVIRTUAL instruction.
    814     *
    815     * @param obj the instruction.
    816     */
    817    void visitINVOKEVIRTUAL(INVOKEVIRTUAL obj);
    818
    819    /**
    820     * Visits an IOR instruction.
    821     *
    822     * @param obj the instruction.
    823     */
    824    void visitIOR(IOR obj);
    825
    826    /**
    827     * Visits an IREM instruction.
    828     *
    829     * @param obj the instruction.
    830     */
    831    void visitIREM(IREM obj);
    832
    833    /**
    834     * Visits an IRETURN instruction.
    835     *
    836     * @param obj the instruction.
    837     */
    838    void visitIRETURN(IRETURN obj);
    839
    840    /**
    841     * Visits an ISHL instruction.
    842     *
    843     * @param obj the instruction.
    844     */
    845    void visitISHL(ISHL obj);
    846
    847    /**
    848     * Visits an ISHR instruction.
    849     *
    850     * @param obj the instruction.
    851     */
    852    void visitISHR(ISHR obj);
    853
    854    /**
    855     * Visits an ISTORE instruction.
    856     *
    857     * @param obj the instruction.
    858     */
    859    void visitISTORE(ISTORE obj);
    860
    861    /**
    862     * Visits an ISUB instruction.
    863     *
    864     * @param obj the instruction.
    865     */
    866    void visitISUB(ISUB obj);
    867
    868    /**
    869     * Visits an IUSHR instruction.
    870     *
    871     * @param obj the instruction.
    872     */
    873    void visitIUSHR(IUSHR obj);
    874
    875    /**
    876     * Visits an IXOR instruction.
    877     *
    878     * @param obj the instruction.
    879     */
    880    void visitIXOR(IXOR obj);
    881
    882    /**
    883     * Visits a JSR instruction.
    884     *
    885     * @param obj the instruction.
    886     */
    887    void visitJSR(JSR obj);
    888
    889    /**
    890     * Visits a JSR_W instruction.
    891     *
    892     * @param obj the instruction.
    893     */
    894    void visitJSR_W(JSR_W obj);
    895
    896    /**
    897     * Visits a JsrInstruction.
    898     *
    899     * @param obj the instruction.
    900     */
    901    void visitJsrInstruction(JsrInstruction obj);
    902
    903    /**
    904     * Visits an L2D instruction.
    905     *
    906     * @param obj the instruction.
    907     */
    908    void visitL2D(L2D obj);
    909
    910    /**
    911     * Visits an L2F instruction.
    912     *
    913     * @param obj the instruction.
    914     */
    915    void visitL2F(L2F obj);
    916
    917    /**
    918     * Visits an L2I instruction.
    919     *
    920     * @param obj the instruction.
    921     */
    922    void visitL2I(L2I obj);
    923
    924    /**
    925     * Visits an LADD instruction.
    926     *
    927     * @param obj the instruction.
    928     */
    929    void visitLADD(LADD obj);
    930
    931    /**
    932     * Visits an LALOAD instruction.
    933     *
    934     * @param obj the instruction.
    935     */
    936    void visitLALOAD(LALOAD obj);
    937
    938    /**
    939     * Visits an LAND instruction.
    940     *
    941     * @param obj the instruction.
    942     */
    943    void visitLAND(LAND obj);
    944
    945    /**
    946     * Visits an LASTORE instruction.
    947     *
    948     * @param obj the instruction.
    949     */
    950    void visitLASTORE(LASTORE obj);
    951
    952    /**
    953     * Visits an LCMP instruction.
    954     *
    955     * @param obj the instruction.
    956     */
    957    void visitLCMP(LCMP obj);
    958
    959    /**
    960     * Visits an LCONST instruction.
    961     *
    962     * @param obj the instruction.
    963     */
    964    void visitLCONST(LCONST obj);
    965
    966    /**
    967     * Visits an LDC instruction.
    968     *
    969     * @param obj the instruction.
    970     */
    971    void visitLDC(LDC obj);
    972
    973    /**
    974     * Visits an LDC2_W instruction.
    975     *
    976     * @param obj the instruction.
    977     */
    978    void visitLDC2_W(LDC2_W obj);
    979
    980    /**
    981     * Visits an LDIV instruction.
    982     *
    983     * @param obj the instruction.
    984     */
    985    void visitLDIV(LDIV obj);
    986
    987    /**
    988     * Visits an LLOAD instruction.
    989     *
    990     * @param obj the instruction.
    991     */
    992    void visitLLOAD(LLOAD obj);
    993
    994    /**
    995     * Visits an LMUL instruction.
    996     *
    997     * @param obj the instruction.
    998     */
    999    void visitLMUL(LMUL obj);
    1000
    1001    /**
    1002     * Visits an LNEG instruction.
    1003     *
    1004     * @param obj the instruction.
    1005     */
    1006    void visitLNEG(LNEG obj);
    1007
    1008    /**
    1009     * Visits a LoadClass.
    1010     *
    1011     * @param obj the load class.
    1012     */
    1013    void visitLoadClass(LoadClass obj);
    1014
    1015    /**
    1016     * Visits a LoadInstruction.
    1017     *
    1018     * @param obj the instruction.
    1019     */
    1020    void visitLoadInstruction(LoadInstruction obj);
    1021
    1022    /**
    1023     * Visits a LocalVariableInstruction.
    1024     *
    1025     * @param obj the instruction.
    1026     */
    1027    void visitLocalVariableInstruction(LocalVariableInstruction obj);
    1028
    1029    /**
    1030     * Visits a LOOKUPSWITCH instruction.
    1031     *
    1032     * @param obj the instruction.
    1033     */
    1034    void visitLOOKUPSWITCH(LOOKUPSWITCH obj);
    1035
    1036    /**
    1037     * Visits an LOR instruction.
    1038     *
    1039     * @param obj the instruction.
    1040     */
    1041    void visitLOR(LOR obj);
    1042
    1043    /**
    1044     * Visits an LREM instruction.
    1045     *
    1046     * @param obj the instruction.
    1047     */
    1048    void visitLREM(LREM obj);
    1049
    1050    /**
    1051     * Visits an LRETURN instruction.
    1052     *
    1053     * @param obj the instruction.
    1054     */
    1055    void visitLRETURN(LRETURN obj);
    1056
    1057    /**
    1058     * Visits an LSHL instruction.
    1059     *
    1060     * @param obj the instruction.
    1061     */
    1062    void visitLSHL(LSHL obj);
    1063
    1064    /**
    1065     * Visits an LSHR instruction.
    1066     *
    1067     * @param obj the instruction.
    1068     */
    1069    void visitLSHR(LSHR obj);
    1070
    1071    /**
    1072     * Visits an LSTORE instruction.
    1073     *
    1074     * @param obj the instruction.
    1075     */
    1076    void visitLSTORE(LSTORE obj);
    1077
    1078    /**
    1079     * Visits an LSUB instruction.
    1080     *
    1081     * @param obj the instruction.
    1082     */
    1083    void visitLSUB(LSUB obj);
    1084
    1085    /**
    1086     * Visits an LUSHR instruction.
    1087     *
    1088     * @param obj the instruction.
    1089     */
    1090    void visitLUSHR(LUSHR obj);
    1091
    1092    /**
    1093     * Visits an LXOR instruction.
    1094     *
    1095     * @param obj the instruction.
    1096     */
    1097    void visitLXOR(LXOR obj);
    1098
    1099    /**
    1100     * Visits a MONITORENTER instruction.
    1101     *
    1102     * @param obj the instruction.
    1103     */
    1104    void visitMONITORENTER(MONITORENTER obj);
    1105
    1106    /**
    1107     * Visits a MONITOREXIT instruction.
    1108     *
    1109     * @param obj the instruction.
    1110     */
    1111    void visitMONITOREXIT(MONITOREXIT obj);
    1112
    1113    /**
    1114     * Visits a MULTIANEWARRAY instruction.
    1115     *
    1116     * @param obj the instruction.
    1117     */
    1118    void visitMULTIANEWARRAY(MULTIANEWARRAY obj);
    1119
    1120    /**
    1121     * Visits a NEW instruction.
    1122     *
    1123     * @param obj the instruction.
    1124     */
    1125    void visitNEW(NEW obj);
    1126
    1127    /**
    1128     * Visits a NEWARRAY instruction.
    1129     *
    1130     * @param obj the instruction.
    1131     */
    1132    void visitNEWARRAY(NEWARRAY obj);
    1133
    1134    /**
    1135     * Visits a NOP instruction.
    1136     *
    1137     * @param obj the instruction.
    1138     */
    1139    void visitNOP(NOP obj);
    1140
    1141    /**
    1142     * Visits a POP instruction.
    1143     *
    1144     * @param obj the instruction.
    1145     */
    1146    void visitPOP(POP obj);
    1147
    1148    /**
    1149     * Visits a POP2 instruction.
    1150     *
    1151     * @param obj the instruction.
    1152     */
    1153    void visitPOP2(POP2 obj);
    1154
    1155    /**
    1156     * Visits a PopInstruction.
    1157     *
    1158     * @param obj the instruction.
    1159     */
    1160    void visitPopInstruction(PopInstruction obj);
    1161
    1162    /**
    1163     * Visits a PushInstruction.
    1164     *
    1165     * @param obj the instruction.
    1166     */
    1167    void visitPushInstruction(PushInstruction obj);
    1168
    1169    /**
    1170     * Visits a PUTFIELD instruction.
    1171     *
    1172     * @param obj the instruction.
    1173     */
    1174    void visitPUTFIELD(PUTFIELD obj);
    1175
    1176    /**
    1177     * Visits a PUTSTATIC instruction.
    1178     *
    1179     * @param obj the instruction.
    1180     */
    1181    void visitPUTSTATIC(PUTSTATIC obj);
    1182
    1183    /**
    1184     * Visits a RET instruction.
    1185     *
    1186     * @param obj the instruction.
    1187     */
    1188    void visitRET(RET obj);
    1189
    1190    /**
    1191     * Visits a RETURN instruction.
    1192     *
    1193     * @param obj the instruction.
    1194     */
    1195    void visitRETURN(RETURN obj);
    1196
    1197    /**
    1198     * Visits a ReturnInstruction.
    1199     *
    1200     * @param obj the instruction.
    1201     */
    1202    void visitReturnInstruction(ReturnInstruction obj);
    1203
    1204    /**
    1205     * Visits a SALOAD instruction.
    1206     *
    1207     * @param obj the instruction.
    1208     */
    1209    void visitSALOAD(SALOAD obj);
    1210
    1211    /**
    1212     * Visits a SASTORE instruction.
    1213     *
    1214     * @param obj the instruction.
    1215     */
    1216    void visitSASTORE(SASTORE obj);
    1217
    1218    /**
    1219     * Visits a Select instruction.
    1220     *
    1221     * @param obj the instruction.
    1222     */
    1223    void visitSelect(Select obj);
    1224
    1225    /**
    1226     * Visits a SIPUSH instruction.
    1227     *
    1228     * @param obj the instruction.
    1229     */
    1230    void visitSIPUSH(SIPUSH obj);
    1231
    1232    /**
    1233     * Visits a StackConsumer.
    1234     *
    1235     * @param obj the instruction.
    1236     */
    1237    void visitStackConsumer(StackConsumer obj);
    1238
    1239    /**
    1240     * Visits a StackInstruction.
    1241     *
    1242     * @param obj the instruction.
    1243     */
    1244    void visitStackInstruction(StackInstruction obj);
    1245
    1246    /**
    1247     * Visits a StackProducer.
    1248     *
    1249     * @param obj the instruction.
    1250     */
    1251    void visitStackProducer(StackProducer obj);
    1252
    1253    /**
    1254     * Visits a StoreInstruction.
    1255     *
    1256     * @param obj the instruction.
    1257     */
    1258    void visitStoreInstruction(StoreInstruction obj);
    1259
    1260    /**
    1261     * Visits a SWAP instruction.
    1262     *
    1263     * @param obj the instruction.
    1264     */
    1265    void visitSWAP(SWAP obj);
    1266
    1267    /**
    1268     * Visits a TABLESWITCH instruction.
    1269     *
    1270     * @param obj the instruction.
    1271     */
    1272    void visitTABLESWITCH(TABLESWITCH obj);
    1273
    1274    /**
    1275     * Visits a TypedInstruction.
    1276     *
    1277     * @param obj the instruction.
    1278     */
    1279    void visitTypedInstruction(TypedInstruction obj);
    1280
    1281    /**
    1282     * Visits an UnconditionalBranch.
    1283     *
    1284     * @param obj the instruction.
    1285     */
    1286    void visitUnconditionalBranch(UnconditionalBranch obj);
    1287
    1288    /**
    1289     * Visits a VariableLengthInstruction.
    1290     *
    1291     * @param obj the instruction.
    1292     */
    1293    void visitVariableLengthInstruction(VariableLengthInstruction obj);
    1294}