API tools faq
paste
Advertisement
Guest User

Magic hell

a guest
Oct 14th, 2019
89
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 17.21 KB | None | 0 0
raw download clone embed print report
  1. package ru.progrm_jarvis.asminj.tools.instruction;
  2.  
  3. import lombok.NonNull;
  4. import lombok.experimental.UtilityClass;
  5. import lombok.val;
  6. import lombok.var;
  7. import org.objectweb.asm.MethodVisitor;
  8. import ru.progrm_jarvis.asminj.tools.instruction.serialization.InstructionDecoderException;
  9. import ru.progrm_jarvis.asminj.tools.instruction.serialization.SimpleOperandReader;
  10.  
  11. import java.util.Locale;
  12. import java.util.regex.Pattern;
  13.  
  14. import static org.objectweb.asm.Opcodes.*;
  15.  
  16. @UtilityClass
  17. public class InstructionParser {
  18.  
  19.     private final Pattern ARGUMENTS_SPLIT_PATTERN = Pattern.compile("\\s+");
  20.  
  21.     @SuppressWarnings("SpellCheckingInspection") // instruction names
  22.     public void insertRawBytecode(@NonNull final MethodVisitor method, @NonNull String instruction) {
  23.         instruction = instruction.trim(); // both side spaces
  24.         var delimiter = instruction.indexOf(' ');
  25.  
  26.         // without operands
  27.         if (delimiter == -1) switch (instruction.toUpperCase(Locale.US)) {
  28.             // <editor-fold desc="No-operand opcode names" defaultstate="collapsed">
  29.             case "AALOAD": {
  30.                 method.visitInsn(AALOAD);
  31.                 return;
  32.             }
  33.             case "AASTORE": {
  34.                 method.visitInsn(AASTORE);
  35.                 return;
  36.             }
  37.             case "ACONST_NULL": {
  38.                 method.visitInsn(ACONST_NULL);
  39.                 return;
  40.             }
  41.             case "ALOAD_0": {
  42.                 method.visitVarInsn(ALOAD, 0);
  43.                 return;
  44.             }
  45.             case "ALOAD_1": {
  46.                 method.visitVarInsn(ALOAD, 1);
  47.                 return;
  48.             }
  49.             case "ALOAD_2": {
  50.                 method.visitVarInsn(ALOAD, 2);
  51.                 return;
  52.             }
  53.             case "ALOAD_3": {
  54.                 method.visitVarInsn(ALOAD, 3);
  55.                 return;
  56.             }
  57.             case "ARETURN": {
  58.                 method.visitInsn(ARETURN);
  59.                 return;
  60.             }
  61.             case "ARRAYLENGTH": {
  62.                 method.visitInsn(ARRAYLENGTH);
  63.                 return;
  64.             }
  65.             case "ASTORE_0": {
  66.                 method.visitVarInsn(ASTORE, 0);
  67.                 return;
  68.             }
  69.             case "ASTORE_1": {
  70.                 method.visitVarInsn(ASTORE, 1);
  71.                 return;
  72.             }
  73.             case "ASTORE_2": {
  74.                 method.visitVarInsn(ASTORE, 2);
  75.                 return;
  76.             }
  77.             case "ASTORE_3": {
  78.                 method.visitVarInsn(ASTORE, 3);
  79.                 return;
  80.             }
  81.             case "ATHROW": {
  82.                 method.visitInsn(ATHROW);
  83.                 return;
  84.             }
  85.             case "BALOAD": {
  86.                 method.visitInsn(BALOAD);
  87.                 return;
  88.             }
  89.             case "BASTORE": {
  90.                 method.visitInsn(BASTORE);
  91.                 return;
  92.             }
  93.             case "BREAKPOINT": {
  94.                 method.visitInsn(0xCA);
  95.                 return;
  96.             }
  97.             case "CALOAD": {
  98.                 method.visitInsn(CALOAD);
  99.                 return;
  100.             }
  101.             case "CASTORE": {
  102.                 method.visitInsn(CASTORE);
  103.                 return;
  104.             }
  105.             case "D2F": {
  106.                 method.visitInsn(D2F);
  107.                 return;
  108.             }
  109.             case "D2I": {
  110.                 method.visitInsn(D2I);
  111.                 return;
  112.             }
  113.             case "D2L": {
  114.                 method.visitInsn(D2L);
  115.                 return;
  116.             }
  117.             case "DADD": {
  118.                 method.visitInsn(DADD);
  119.                 return;
  120.             }
  121.             case "DALOAD": {
  122.                 method.visitInsn(DALOAD);
  123.                 return;
  124.             }
  125.             case "DASTORE": {
  126.                 method.visitInsn(DASTORE);
  127.                 return;
  128.             }
  129.             case "DCMPG": {
  130.                 method.visitInsn(DCMPG);
  131.                 return;
  132.             }
  133.             case "DCMPL": {
  134.                 method.visitInsn(DCMPG);
  135.                 return;
  136.             }
  137.             case "DCONST_0": {
  138.                 method.visitInsn(DCONST_0);
  139.                 return;
  140.             }
  141.             case "DCONST_1": {
  142.                 method.visitInsn(DCONST_1);
  143.                 return;
  144.             }
  145.             case "DDIV": {
  146.                 method.visitInsn(DDIV);
  147.                 return;
  148.             }
  149.             case "DLOAD_0": {
  150.                 method.visitVarInsn(DLOAD, 0);
  151.                 return;
  152.             }
  153.             case "DLOAD_1": {
  154.                 method.visitVarInsn(DLOAD, 1);
  155.                 return;
  156.             }
  157.             case "DLOAD_2": {
  158.                 method.visitVarInsn(DLOAD, 2);
  159.                 return;
  160.             }
  161.             case "DLOAD_3": {
  162.                 method.visitVarInsn(DLOAD, 3);
  163.                 return;
  164.             }
  165.             case "DMUL": {
  166.                 method.visitInsn(DMUL);
  167.                 return;
  168.             }
  169.             case "DNEG": {
  170.                 method.visitInsn(DNEG);
  171.                 return;
  172.             }
  173.             case "DREM": {
  174.                 method.visitInsn(DREM);
  175.                 return;
  176.             }
  177.             case "DRETURN": {
  178.                 method.visitInsn(DRETURN);
  179.                 return;
  180.             }
  181.             case "DSTORE_0": {
  182.                 method.visitVarInsn(DSTORE, 0);
  183.                 return;
  184.             }
  185.             case "DSTORE_1": {
  186.                 method.visitVarInsn(DSTORE, 1);
  187.                 return;
  188.             }
  189.             case "DSTORE_2": {
  190.                 method.visitVarInsn(DSTORE, 2);
  191.                 return;
  192.             }
  193.             case "DSTORE_3": {
  194.                 method.visitVarInsn(DSTORE, 3);
  195.                 return;
  196.             }
  197.             case "DSUB": {
  198.                 method.visitInsn(DREM);
  199.                 return;
  200.             }
  201.             case "DUP": {
  202.                 method.visitInsn(DUP);
  203.                 return;
  204.             }
  205.             case "DUP_X1": {
  206.                 method.visitInsn(DUP_X1);
  207.                 return;
  208.             }
  209.             case "DUP2": {
  210.                 method.visitInsn(DUP2);
  211.                 return;
  212.             }
  213.             case "DUP2_X1": {
  214.                 method.visitInsn(DUP2_X1);
  215.                 return;
  216.             }
  217.             case "DUP2_X2": {
  218.                 method.visitInsn(DUP2_X2);
  219.                 return;
  220.             }
  221.             case "F2D": {
  222.                 method.visitInsn(F2D);
  223.                 return;
  224.             }
  225.             case "F2I": {
  226.                 method.visitInsn(F2I);
  227.                 return;
  228.             }
  229.             case "F2L": {
  230.                 method.visitInsn(F2L);
  231.                 return;
  232.             }
  233.             case "FADD": {
  234.                 method.visitInsn(FADD);
  235.                 return;
  236.             }
  237.             case "FALOAD": {
  238.                 method.visitInsn(FALOAD);
  239.                 return;
  240.             }
  241.             case "FASTORE": {
  242.                 method.visitInsn(FASTORE);
  243.                 return;
  244.             }
  245.             case "FLOAD_0": {
  246.                 method.visitVarInsn(FLOAD, 0);
  247.                 return;
  248.             }
  249.             case "FLOAD_1": {
  250.                 method.visitVarInsn(FLOAD, 1);
  251.                 return;
  252.             }
  253.             case "FLOAD_2": {
  254.                 method.visitVarInsn(FLOAD, 2);
  255.                 return;
  256.             }
  257.             case "FLOAD_3": {
  258.                 method.visitVarInsn(FLOAD, 2);
  259.                 return;
  260.             }
  261.             case "FMUL": {
  262.                 method.visitInsn(FMUL);
  263.                 return;
  264.             }
  265.             case "FNEG": {
  266.                 method.visitInsn(FNEG);
  267.                 return;
  268.             }
  269.             case "FREM": {
  270.                 method.visitInsn(FREM);
  271.                 return;
  272.             }
  273.             case "FRETURN": {
  274.                 method.visitInsn(FRETURN);
  275.                 return;
  276.             }
  277.             case "FSTORE_0": {
  278.                 method.visitVarInsn(FSTORE, 0);
  279.                 return;
  280.             }
  281.             case "FSTORE_1": {
  282.                 method.visitVarInsn(FSTORE, 1);
  283.                 return;
  284.             }
  285.             case "FSTORE_2": {
  286.                 method.visitVarInsn(FSTORE, 2);
  287.                 return;
  288.             }
  289.             case "FSTORE_3": {
  290.                 method.visitVarInsn(FSTORE, 3);
  291.                 return;
  292.             }
  293.             case "FSUB": {
  294.                 method.visitInsn(FSUB);
  295.                 return;
  296.             }
  297.             case "I2B": {
  298.                 method.visitInsn(I2B);
  299.                 return;
  300.             }
  301.             case "I2C": {
  302.                 method.visitInsn(I2C);
  303.                 return;
  304.             }
  305.             case "I2D": {
  306.                 method.visitInsn(I2D);
  307.                 return;
  308.             }
  309.             case "I2F": {
  310.                 method.visitInsn(I2F);
  311.                 return;
  312.             }
  313.             case "I2L": {
  314.                 method.visitInsn(I2L);
  315.                 return;
  316.             }
  317.             case "I2S": {
  318.                 method.visitInsn(I2S);
  319.                 return;
  320.             }
  321.             case "IADD": {
  322.                 method.visitInsn(IADD);
  323.                 return;
  324.             }
  325.             case "IALOAD": {
  326.                 method.visitInsn(IALOAD);
  327.                 return;
  328.             }
  329.             case "IAND": {
  330.                 method.visitInsn(IAND);
  331.                 return;
  332.             }
  333.             case "IASTORE": {
  334.                 method.visitInsn(IASTORE);
  335.                 return;
  336.             }
  337.             case "ICONST_M1": {
  338.                 method.visitInsn(ICONST_M1);
  339.                 return;
  340.             }
  341.             case "ICONST_0": {
  342.                 method.visitInsn(ICONST_0);
  343.                 return;
  344.             }
  345.             case "ICONST_1": {
  346.                 method.visitInsn(ICONST_1);
  347.                 return;
  348.             }
  349.             case "ICONST_2": {
  350.                 method.visitInsn(ICONST_2);
  351.                 return;
  352.             }
  353.             case "ICONST_3": {
  354.                 method.visitInsn(ICONST_3);
  355.                 return;
  356.             }
  357.             case "ICONST_4": {
  358.                 method.visitInsn(ICONST_4);
  359.                 return;
  360.             }
  361.             case "ICONST_5": {
  362.                 method.visitInsn(ICONST_5);
  363.                 return;
  364.             }
  365.             case "IDIV": {
  366.                 method.visitInsn(IDIV);
  367.                 return;
  368.             }
  369.             case "ILOAD_0": {
  370.                 method.visitVarInsn(ILOAD, 0);
  371.                 return;
  372.             }
  373.             case "ILOAD_1": {
  374.                 method.visitVarInsn(ILOAD, 1);
  375.                 return;
  376.             }
  377.             case "ILOAD_2": {
  378.                 method.visitVarInsn(ILOAD, 2);
  379.                 return;
  380.             }
  381.             case "ILOAD_3": {
  382.                 method.visitVarInsn(ILOAD, 3);
  383.                 return;
  384.             }
  385.             case "IMPDEP1": {
  386.                 method.visitInsn(0xFE);
  387.                 return;
  388.             }
  389.             case "IMPDEP2": {
  390.                 method.visitInsn(0xFF);
  391.                 return;
  392.             }
  393.             case "IMUL": {
  394.                 method.visitInsn(IMUL);
  395.                 return;
  396.             }
  397.             case "INEG": {
  398.                 method.visitInsn(INEG);
  399.                 return;
  400.             }
  401.             case "IOR": {
  402.                 method.visitInsn(IOR);
  403.                 return;
  404.             }
  405.             case "IREM": {
  406.                 method.visitInsn(IREM);
  407.                 return;
  408.             }
  409.             case "IRETURN": {
  410.                 method.visitInsn(IRETURN);
  411.                 return;
  412.             }
  413.             case "ISHL": {
  414.                 method.visitInsn(ISHL);
  415.                 return;
  416.             }
  417.             case "ISHR": {
  418.                 method.visitInsn(ISHR);
  419.                 return;
  420.             }
  421.             case "ISTORE_0": {
  422.                 method.visitVarInsn(ISTORE, 0);
  423.                 return;
  424.             }
  425.             case "ISTORE_1": {
  426.                 method.visitVarInsn(ISTORE, 1);
  427.                 return;
  428.             }
  429.             case "ISTORE_2": {
  430.                 method.visitVarInsn(ISTORE, 2);
  431.                 return;
  432.             }
  433.             case "ISTORE_3": {
  434.                 method.visitVarInsn(ISTORE, 3);
  435.                 return;
  436.             }
  437.             case "ISUB": {
  438.                 method.visitInsn(ISUB);
  439.                 return;
  440.             }
  441.             case "IUSHR": {
  442.                 method.visitInsn(IUSHR);
  443.                 return;
  444.             }
  445.             case "IXOR": {
  446.                 method.visitInsn(IXOR);
  447.                 return;
  448.             }
  449.             case "L2D": {
  450.                 method.visitInsn(L2D);
  451.                 return;
  452.             }
  453.             case "L2F": {
  454.                 method.visitInsn(L2F);
  455.                 return;
  456.             }
  457.             case "L2I": {
  458.                 method.visitInsn(L2I);
  459.                 return;
  460.             }
  461.             case "LADD": {
  462.                 method.visitInsn(LADD);
  463.                 return;
  464.             }
  465.             case "LALOAD": {
  466.                 method.visitInsn(LALOAD);
  467.                 return;
  468.             }
  469.             case "LAND": {
  470.                 method.visitInsn(LAND);
  471.                 return;
  472.             }
  473.             case "LASTORE": {
  474.                 method.visitInsn(LASTORE);
  475.                 return;
  476.             }
  477.             case "LCMP": {
  478.                 method.visitInsn(LCMP);
  479.                 return;
  480.             }
  481.             case "LCONST_0": {
  482.                 method.visitInsn(LCONST_0);
  483.                 return;
  484.             }
  485.             case "LCONST_1": {
  486.                 method.visitInsn(LCONST_1);
  487.                 return;
  488.             }
  489.             case "LDIV": {
  490.                 method.visitInsn(LDIV);
  491.                 return;
  492.             }
  493.             case "LLOAD_0": {
  494.                 method.visitVarInsn(LLOAD, 0);
  495.                 return;
  496.             }
  497.             case "LLOAD_1": {
  498.                 method.visitVarInsn(LLOAD, 1);
  499.                 return;
  500.             }
  501.             case "LLOAD_2": {
  502.                 method.visitVarInsn(LLOAD, 2);
  503.                 return;
  504.             }
  505.             case "LLOAD_3": {
  506.                 method.visitVarInsn(LLOAD, 3);
  507.                 return;
  508.             }
  509.             case "LMUL": {
  510.                 method.visitInsn(LMUL);
  511.                 return;
  512.             }
  513.             case "LNEG": {
  514.                 method.visitInsn(LNEG);
  515.                 return;
  516.             }
  517.             case "LOR": {
  518.                 method.visitInsn(LOR);
  519.                 return;
  520.             }
  521.             case "LREM": {
  522.                 method.visitInsn(LREM);
  523.                 return;
  524.             }
  525.             case "LRETURN": {
  526.                 method.visitInsn(LRETURN);
  527.                 return;
  528.             }
  529.             case "LSHL": {
  530.                 method.visitInsn(LSHL);
  531.                 return;
  532.             }
  533.             case "LSHR": {
  534.                 method.visitInsn(LSHR);
  535.                 return;
  536.             }
  537.             case "LSTORE_0": {
  538.                 method.visitVarInsn(LSTORE, 0);
  539.                 return;
  540.             }
  541.             case "LSTORE_1": {
  542.                 method.visitVarInsn(LSTORE, 1);
  543.                 return;
  544.             }
  545.             case "LSTORE_2": {
  546.                 method.visitVarInsn(LSTORE, 2);
  547.                 return;
  548.             }
  549.             case "LSTORE_3": {
  550.                 method.visitVarInsn(LSTORE, 3);
  551.                 return;
  552.             }
  553.             case "LSUB": {
  554.                 method.visitInsn(LSUB);
  555.                 return;
  556.             }
  557.             case "LUSHR": {
  558.                 method.visitInsn(LUSHR);
  559.                 return;
  560.             }
  561.             case "LXOR": {
  562.                 method.visitInsn(LXOR);
  563.                 return;
  564.             }
  565.             case "MONITORENTER": {
  566.                 method.visitInsn(MONITORENTER);
  567.                 return;
  568.             }
  569.             case "MONITOREXIT": {
  570.                 method.visitInsn(MONITOREXIT);
  571.                 return;
  572.             }
  573.             case "NOP": {
  574.                 method.visitInsn(NOP);
  575.                 return;
  576.             }
  577.             case "POP": {
  578.                 method.visitInsn(POP);
  579.                 return;
  580.             }
  581.             case "POP2": {
  582.                 method.visitInsn(POP2);
  583.                 return;
  584.             }
  585.             case "RETURN": {
  586.                 method.visitInsn(RETURN);
  587.                 return;
  588.             }
  589.             case "SALOAD": {
  590.                 method.visitInsn(SALOAD);
  591.                 return;
  592.             }
  593.             case "SASTORE": {
  594.                 method.visitInsn(SASTORE);
  595.                 return;
  596.             }
  597.             case "SWAP": {
  598.                 method.visitInsn(SWAP);
  599.                 return;
  600.             }
  601.             default: throw new InstructionDecoderException(
  602.                     "Unable to find no-operand OPCODE <" + instruction + '>'
  603.             );
  604.             // </editor-fold>
  605.         }
  606.         // with oppperands
  607.         else { // there are arguments
  608.             val operators = SimpleOperandReader.from(instruction.substring(delimiter));
  609.             switch (instruction.substring(0, delimiter).toUpperCase(Locale.US)) {
  610.                 case "ALOAD": {
  611.                     method.visitVarInsn(ALOAD, operators.readInt());
  612.                     return;
  613.                 }
  614.                 case "ANEWARRAY": {
  615.                     method.visitTypeInsn(ANEWARRAY, operators.readInternalClassName());
  616.                     return;
  617.                 }
  618.                 // TODO: 15.10.2019 Implement all other
  619.             }
  620.         }
  621.     }
  622. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!