BcBands.java

  1. /*
  2.  *  Licensed to the Apache Software Foundation (ASF) under one or more
  3.  *  contributor license agreements.  See the NOTICE file distributed with
  4.  *  this work for additional information regarding copyright ownership.
  5.  *  The ASF licenses this file to You under the Apache License, Version 2.0
  6.  *  (the "License"); you may not use this file except in compliance with
  7.  *  the License.  You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  *  Unless required by applicable law or agreed to in writing, software
  12.  *  distributed under the License is distributed on an "AS IS" BASIS,
  13.  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  *  See the License for the specific language governing permissions and
  15.  *  limitations under the License.
  16.  */
  17. package org.apache.commons.compress.harmony.unpack200;

  19. import java.io.ByteArrayOutputStream;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.util.ArrayList;
  23. import java.util.Collections;
  24. import java.util.List;

  26. import org.apache.commons.compress.harmony.pack200.Codec;
  27. import org.apache.commons.compress.harmony.pack200.Pack200Exception;
  28. import org.apache.commons.compress.harmony.unpack200.bytecode.Attribute;
  29. import org.apache.commons.compress.harmony.unpack200.bytecode.BCIRenumberedAttribute;
  30. import org.apache.commons.compress.harmony.unpack200.bytecode.ByteCode;
  31. import org.apache.commons.compress.harmony.unpack200.bytecode.CPClass;
  32. import org.apache.commons.compress.harmony.unpack200.bytecode.CodeAttribute;
  33. import org.apache.commons.compress.harmony.unpack200.bytecode.ExceptionTableEntry;
  34. import org.apache.commons.compress.harmony.unpack200.bytecode.NewAttribute;
  35. import org.apache.commons.compress.harmony.unpack200.bytecode.OperandManager;

  37. /**
  38.  * Bytecode bands
  39.  */
  40. public class BcBands extends BandSet {

  42.     // The bytecodes for each method in each class as they come (i.e. in their
  43.     // packed format)
  44.     private byte[][][] methodByteCodePacked;

  46.     // The bands
  47.     // TODO: Haven't resolved references yet. Do we want to?
  48.     private int[] bcCaseCount;
  49.     private int[] bcCaseValue;
  50.     private int[] bcByte;
  51.     private int[] bcLocal;
  52.     private int[] bcShort;
  53.     private int[] bcLabel;
  54.     private int[] bcIntRef;
  55.     private int[] bcFloatRef;
  56.     private int[] bcLongRef;
  57.     private int[] bcDoubleRef;
  58.     private int[] bcStringRef;
  59.     private int[] bcClassRef;
  60.     private int[] bcFieldRef;
  61.     private int[] bcMethodRef;
  62.     private int[] bcIMethodRef;
  63.     private int[] bcThisField;
  64.     private int[] bcSuperField;
  65.     private int[] bcThisMethod;
  66.     private int[] bcSuperMethod;
  67.     private int[] bcInitRef;
  68.     private int[] bcEscRef;
  69.     private int[] bcEscRefSize;
  70.     private int[] bcEscSize;
  71.     private int[][] bcEscByte;

  73.     private List<Integer> wideByteCodes;

  75.     /**
  76.      * @param segment TODO
  77.      */
  78.     public BcBands(final Segment segment) {
  79.         super(segment);
  80.     }

  82.     private boolean endsWithLoad(final int codePacked) {
  83.         return codePacked >= 21 && codePacked <= 25;
  84.     }

  86.     private boolean endsWithStore(final int codePacked) {
  87.         return codePacked >= 54 && codePacked <= 58;
  88.     }

  90.     public int[] getBcByte() {
  91.         return bcByte;
  92.     }

  94.     public int[] getBcCaseCount() {
  95.         return bcCaseCount;
  96.     }

  98.     public int[] getBcCaseValue() {
  99.         return bcCaseValue;
  100.     }

  102.     public int[] getBcClassRef() {
  103.         return bcClassRef;
  104.     }

  106.     public int[] getBcDoubleRef() {
  107.         return bcDoubleRef;
  108.     }

  110.     public int[] getBcFieldRef() {
  111.         return bcFieldRef;
  112.     }

  114.     public int[] getBcFloatRef() {
  115.         return bcFloatRef;
  116.     }

  118.     public int[] getBcIMethodRef() {
  119.         return bcIMethodRef;
  120.     }

  122.     public int[] getBcInitRef() {
  123.         return bcInitRef;
  124.     }

  126.     public int[] getBcIntRef() {
  127.         return bcIntRef;
  128.     }

  130.     public int[] getBcLabel() {
  131.         return bcLabel;
  132.     }

  134.     public int[] getBcLocal() {
  135.         return bcLocal;
  136.     }

  138.     public int[] getBcLongRef() {
  139.         return bcLongRef;
  140.     }

  142.     public int[] getBcMethodRef() {
  143.         return bcMethodRef;
  144.     }

  146.     public int[] getBcShort() {
  147.         return bcShort;
  148.     }

  150.     public int[] getBcStringRef() {
  151.         return bcStringRef;
  152.     }

  154.     public int[] getBcSuperField() {
  155.         return bcSuperField;
  156.     }

  158.     public int[] getBcSuperMethod() {
  159.         return bcSuperMethod;
  160.     }

  162.     public int[] getBcThisField() {
  163.         return bcThisField;
  164.     }

  166.     public int[] getBcThisMethod() {
  167.         return bcThisMethod;
  168.     }

  170.     public byte[][][] getMethodByteCodePacked() {
  171.         return methodByteCodePacked;
  172.     }

  174.     /*
  175.      * (non-Javadoc)
  176.      *
  177.      * @see org.apache.commons.compress.harmony.unpack200.BandSet#unpack(java.io.InputStream)
  178.      */
  179.     @Override
  180.     public void read(final InputStream in) throws IOException, Pack200Exception {

  182.         final AttributeLayoutMap attributeDefinitionMap = segment.getAttrDefinitionBands().getAttributeDefinitionMap();
  183.         final int classCount = header.getClassCount();
  184.         final long[][] methodFlags = segment.getClassBands().getMethodFlags();

  186.         int bcCaseCountCount = 0;
  187.         int bcByteCount = 0;
  188.         int bcShortCount = 0;
  189.         int bcLocalCount = 0;
  190.         int bcLabelCount = 0;
  191.         int bcIntRefCount = 0;
  192.         int bcFloatRefCount = 0;
  193.         int bcLongRefCount = 0;
  194.         int bcDoubleRefCount = 0;
  195.         int bcStringRefCount = 0;
  196.         int bcClassRefCount = 0;
  197.         int bcFieldRefCount = 0;
  198.         int bcMethodRefCount = 0;
  199.         int bcIMethodRefCount = 0;
  200.         int bcThisFieldCount = 0;
  201.         int bcSuperFieldCount = 0;
  202.         int bcThisMethodCount = 0;
  203.         int bcSuperMethodCount = 0;
  204.         int bcInitRefCount = 0;
  205.         int bcEscCount = 0;
  206.         int bcEscRefCount = 0;

  208.         final AttributeLayout abstractModifier = attributeDefinitionMap.getAttributeLayout(AttributeLayout.ACC_ABSTRACT, AttributeLayout.CONTEXT_METHOD);
  209.         final AttributeLayout nativeModifier = attributeDefinitionMap.getAttributeLayout(AttributeLayout.ACC_NATIVE, AttributeLayout.CONTEXT_METHOD);

  211.         methodByteCodePacked = new byte[classCount][][];

  213.         final List<Boolean> switchIsTableSwitch = new ArrayList<>();
  214.         wideByteCodes = new ArrayList<>();
  215.         for (int c = 0; c < classCount; c++) {
  216.             final int numberOfMethods = methodFlags[c].length;
  217.             methodByteCodePacked[c] = new byte[numberOfMethods][];
  218.             for (int m = 0; m < numberOfMethods; m++) {
  219.                 final long methodFlag = methodFlags[c][m];
  220.                 if (!abstractModifier.matches(methodFlag) && !nativeModifier.matches(methodFlag)) {
  221.                     final ByteArrayOutputStream codeBytes = new ByteArrayOutputStream();
  222.                     byte code;
  223.                     while ((code = (byte) (0xff & in.read())) != -1) {
  224.                         codeBytes.write(code);
  225.                     }
  226.                     methodByteCodePacked[c][m] = codeBytes.toByteArray();
  227.                     final int[] codes = new int[methodByteCodePacked[c][m].length];
  228.                     for (int i = 0; i < codes.length; i++) {
  229.                         codes[i] = methodByteCodePacked[c][m][i] & 0xff;
  230.                     }
  231.                     for (int i = 0; i < methodByteCodePacked[c][m].length; i++) {
  232.                         final int codePacked = 0xff & methodByteCodePacked[c][m][i];
  233.                         switch (codePacked) {
  234.                         case 16: // bipush
  235.                         case 188: // newarray
  236.                             bcByteCount++;
  237.                             break;
  238.                         case 17: // sipush
  239.                             bcShortCount++;
  240.                             break;
  241.                         case 18: // (a)ldc
  242.                         case 19: // aldc_w
  243.                             bcStringRefCount++;
  244.                             break;
  245.                         case 234: // ildc
  246.                         case 237: // ildc_w
  247.                             bcIntRefCount++;
  248.                             break;
  249.                         case 235: // fldc
  250.                         case 238: // fldc_w
  251.                             bcFloatRefCount++;
  252.                             break;
  253.                         case 197: // multianewarray
  254.                             bcByteCount++;
  255.                             // fallthrough intended
  256.                         case 233: // cldc
  257.                         case 236: // cldc_w
  258.                         case 187: // new
  259.                         case 189: // anewarray
  260.                         case 192: // checkcast
  261.                         case 193: // instanceof
  262.                             bcClassRefCount++;
  263.                             break;
  264.                         case 20: // lldc2_w
  265.                             bcLongRefCount++;
  266.                             break;
  267.                         case 239: // dldc2_w
  268.                             bcDoubleRefCount++;
  269.                             break;
  270.                         case 169: // ret
  271.                             bcLocalCount++;
  272.                             break;
  273.                         case 167: // goto
  274.                         case 168: // jsr
  275.                         case 200: // goto_w
  276.                         case 201: // jsr_w
  277.                             bcLabelCount++;
  278.                             break;
  279.                         case 170: // tableswitch
  280.                             switchIsTableSwitch.add(Boolean.TRUE);
  281.                             bcCaseCountCount++;
  282.                             bcLabelCount++;
  283.                             break;
  284.                         case 171: // lookupswitch
  285.                             switchIsTableSwitch.add(Boolean.FALSE);
  286.                             bcCaseCountCount++;
  287.                             bcLabelCount++;
  288.                             break;
  289.                         case 178: // getstatic
  290.                         case 179: // putstatic
  291.                         case 180: // getfield
  292.                         case 181: // putfield
  293.                             bcFieldRefCount++;
  294.                             break;
  295.                         case 182: // invokevirtual
  296.                         case 183: // invokespecial
  297.                         case 184: // invokestatic
  298.                             bcMethodRefCount++;
  299.                             break;
  300.                         case 185: // invokeinterface
  301.                             bcIMethodRefCount++;
  302.                             break;
  303.                         case 202: // getstatic_this
  304.                         case 203: // putstatic_this
  305.                         case 204: // getfield_this
  306.                         case 205: // putfield_this
  307.                         case 209: // aload_0_getstatic_this
  308.                         case 210: // aload_0_putstatic_this
  309.                         case 211: // aload_0_putfield_this
  310.                         case 212: // aload_0_putfield_this
  311.                             bcThisFieldCount++;
  312.                             break;
  313.                         case 206: // invokevirtual_this
  314.                         case 207: // invokespecial_this
  315.                         case 208: // invokestatic_this
  316.                         case 213: // aload_0_invokevirtual_this
  317.                         case 214: // aload_0_invokespecial_this
  318.                         case 215: // aload_0_invokestatic_this
  319.                             bcThisMethodCount++;
  320.                             break;
  321.                         case 216: // getstatic_super
  322.                         case 217: // putstatic_super
  323.                         case 218: // getfield_super
  324.                         case 219: // putfield_super
  325.                         case 223: // aload_0_getstatic_super
  326.                         case 224: // aload_0_putstatic_super
  327.                         case 225: // aload_0_getfield_super
  328.                         case 226: // aload_0_putfield_super
  329.                             bcSuperFieldCount++;
  330.                             break;
  331.                         case 220: // invokevirtual_super
  332.                         case 221: // invokespecial_super
  333.                         case 222: // invokestatic_super
  334.                         case 227: // aload_0_invokevirtual_super
  335.                         case 228: // aload_0_invokespecial_super
  336.                         case 229: // aload_0_invokestatic_super
  337.                             bcSuperMethodCount++;
  338.                             break;
  339.                         case 132: // iinc
  340.                             bcLocalCount++;
  341.                             bcByteCount++;
  342.                             break;
  343.                         case 196: // wide
  344.                             final int nextInstruction = 0xff & methodByteCodePacked[c][m][i + 1];
  345.                             wideByteCodes.add(Integer.valueOf(nextInstruction));
  346.                             if (nextInstruction == 132) { // iinc
  347.                                 bcLocalCount++;
  348.                                 bcShortCount++;
  349.                             } else if (endsWithLoad(nextInstruction) || endsWithStore(nextInstruction) || nextInstruction == 169) {
  350.                                 bcLocalCount++;
  351.                             } else {
  352.                                 segment.log(Segment.LOG_LEVEL_VERBOSE, "Found unhandled " + ByteCode.getByteCode(nextInstruction));
  353.                             }
  354.                             i++;
  355.                             break;
  356.                         case 230: // invokespecial_this_init
  357.                         case 231: // invokespecial_super_init
  358.                         case 232: // invokespecial_new_init
  359.                             bcInitRefCount++;
  360.                             break;
  361.                         case 253: // ref_escape
  362.                             bcEscRefCount++;
  363.                             break;
  364.                         case 254: // byte_escape
  365.                             bcEscCount++;
  366.                             break;
  367.                         default:
  368.                             if (endsWithLoad(codePacked) || endsWithStore(codePacked)) {
  369.                                 bcLocalCount++;
  370.                             } else if (startsWithIf(codePacked)) {
  371.                                 bcLabelCount++;
  372.                             }
  373.                         }
  374.                     }
  375.                 }
  376.             }
  377.         }
  378.         // other bytecode bands
  379.         bcCaseCount = decodeBandInt("bc_case_count", in, Codec.UNSIGNED5, bcCaseCountCount);
  380.         int bcCaseValueCount = 0;
  381.         for (int i = 0; i < bcCaseCount.length; i++) {
  382.             final boolean isTableSwitch = switchIsTableSwitch.get(i).booleanValue();
  383.             if (isTableSwitch) {
  384.                 bcCaseValueCount += 1;
  385.             } else {
  386.                 bcCaseValueCount += bcCaseCount[i];
  387.             }
  388.         }
  389.         bcCaseValue = decodeBandInt("bc_case_value", in, Codec.DELTA5, bcCaseValueCount);
  390.         // Every case value needs a label. We weren't able to count these
  391.         // above, because we didn't know how many cases there were.
  392.         // Have to correct it now.
  393.         for (int index = 0; index < bcCaseCountCount; index++) {
  394.             bcLabelCount += bcCaseCount[index];
  395.         }
  396.         bcByte = decodeBandInt("bc_byte", in, Codec.BYTE1, bcByteCount);
  397.         bcShort = decodeBandInt("bc_short", in, Codec.DELTA5, bcShortCount);
  398.         bcLocal = decodeBandInt("bc_local", in, Codec.UNSIGNED5, bcLocalCount);
  399.         bcLabel = decodeBandInt("bc_label", in, Codec.BRANCH5, bcLabelCount);
  400.         bcIntRef = decodeBandInt("bc_intref", in, Codec.DELTA5, bcIntRefCount);
  401.         bcFloatRef = decodeBandInt("bc_floatref", in, Codec.DELTA5, bcFloatRefCount);
  402.         bcLongRef = decodeBandInt("bc_longref", in, Codec.DELTA5, bcLongRefCount);
  403.         bcDoubleRef = decodeBandInt("bc_doubleref", in, Codec.DELTA5, bcDoubleRefCount);
  404.         bcStringRef = decodeBandInt("bc_stringref", in, Codec.DELTA5, bcStringRefCount);
  405.         bcClassRef = decodeBandInt("bc_classref", in, Codec.UNSIGNED5, bcClassRefCount);
  406.         bcFieldRef = decodeBandInt("bc_fieldref", in, Codec.DELTA5, bcFieldRefCount);
  407.         bcMethodRef = decodeBandInt("bc_methodref", in, Codec.UNSIGNED5, bcMethodRefCount);
  408.         bcIMethodRef = decodeBandInt("bc_imethodref", in, Codec.DELTA5, bcIMethodRefCount);
  409.         bcThisField = decodeBandInt("bc_thisfield", in, Codec.UNSIGNED5, bcThisFieldCount);
  410.         bcSuperField = decodeBandInt("bc_superfield", in, Codec.UNSIGNED5, bcSuperFieldCount);
  411.         bcThisMethod = decodeBandInt("bc_thismethod", in, Codec.UNSIGNED5, bcThisMethodCount);
  412.         bcSuperMethod = decodeBandInt("bc_supermethod", in, Codec.UNSIGNED5, bcSuperMethodCount);
  413.         bcInitRef = decodeBandInt("bc_initref", in, Codec.UNSIGNED5, bcInitRefCount);
  414.         bcEscRef = decodeBandInt("bc_escref", in, Codec.UNSIGNED5, bcEscRefCount);
  415.         bcEscRefSize = decodeBandInt("bc_escrefsize", in, Codec.UNSIGNED5, bcEscRefCount);
  416.         bcEscSize = decodeBandInt("bc_escsize", in, Codec.UNSIGNED5, bcEscCount);
  417.         bcEscByte = decodeBandInt("bc_escbyte", in, Codec.BYTE1, bcEscSize);
  418.     }

  420.     private boolean startsWithIf(final int codePacked) {
  421.         return codePacked >= 153 && codePacked <= 166 || codePacked == 198 || codePacked == 199;
  422.     }

  424.     @Override
  425.     public void unpack() throws Pack200Exception {
  426.         final int classCount = header.getClassCount();
  427.         final long[][] methodFlags = segment.getClassBands().getMethodFlags();
  428.         final int[] codeMaxNALocals = segment.getClassBands().getCodeMaxNALocals();
  429.         final int[] codeMaxStack = segment.getClassBands().getCodeMaxStack();
  430.         final ArrayList<Attribute>[][] methodAttributes = segment.getClassBands().getMethodAttributes();
  431.         final String[][] methodDescr = segment.getClassBands().getMethodDescr();

  433.         final AttributeLayoutMap attributeDefinitionMap = segment.getAttrDefinitionBands().getAttributeDefinitionMap();

  435.         final AttributeLayout abstractModifier = attributeDefinitionMap.getAttributeLayout(AttributeLayout.ACC_ABSTRACT, AttributeLayout.CONTEXT_METHOD);
  436.         final AttributeLayout nativeModifier = attributeDefinitionMap.getAttributeLayout(AttributeLayout.ACC_NATIVE, AttributeLayout.CONTEXT_METHOD);
  437.         final AttributeLayout staticModifier = attributeDefinitionMap.getAttributeLayout(AttributeLayout.ACC_STATIC, AttributeLayout.CONTEXT_METHOD);

  439.         final int[] wideByteCodeArray = new int[wideByteCodes.size()];
  440.         for (int index = 0; index < wideByteCodeArray.length; index++) {
  441.             wideByteCodeArray[index] = wideByteCodes.get(index).intValue();
  442.         }
  443.         final OperandManager operandManager = new OperandManager(bcCaseCount, bcCaseValue, bcByte, bcShort, bcLocal, bcLabel, bcIntRef, bcFloatRef, bcLongRef,
  444.                 bcDoubleRef, bcStringRef, bcClassRef, bcFieldRef, bcMethodRef, bcIMethodRef, bcThisField, bcSuperField, bcThisMethod, bcSuperMethod, bcInitRef,
  445.                 wideByteCodeArray);
  446.         operandManager.setSegment(segment);

  448.         int i = 0;
  449.         final ArrayList<List<Attribute>> orderedCodeAttributes = segment.getClassBands().getOrderedCodeAttributes();
  450.         int codeAttributeIndex = 0;

  452.         // Exception table fields
  453.         final int[] handlerCount = segment.getClassBands().getCodeHandlerCount();
  454.         final int[][] handlerStartPCs = segment.getClassBands().getCodeHandlerStartP();
  455.         final int[][] handlerEndPCs = segment.getClassBands().getCodeHandlerEndPO();
  456.         final int[][] handlerCatchPCs = segment.getClassBands().getCodeHandlerCatchPO();
  457.         final int[][] handlerClassTypes = segment.getClassBands().getCodeHandlerClassRCN();

  459.         final boolean allCodeHasFlags = segment.getSegmentHeader().getOptions().hasAllCodeFlags();
  460.         final boolean[] codeHasFlags = segment.getClassBands().getCodeHasAttributes();

  462.         for (int c = 0; c < classCount; c++) {
  463.             final int numberOfMethods = methodFlags[c].length;
  464.             for (int m = 0; m < numberOfMethods; m++) {
  465.                 final long methodFlag = methodFlags[c][m];
  466.                 if (!abstractModifier.matches(methodFlag) && !nativeModifier.matches(methodFlag)) {
  467.                     final int maxStack = codeMaxStack[i];
  468.                     int maxLocal = codeMaxNALocals[i];
  469.                     if (!staticModifier.matches(methodFlag)) {
  470.                         maxLocal++; // one for 'this' parameter
  471.                     }
  472.                     // I believe this has to take wide arguments into account
  473.                     maxLocal += SegmentUtils.countInvokeInterfaceArgs(methodDescr[c][m]);
  474.                     final String[] cpClass = segment.getCpBands().getCpClass();
  475.                     operandManager.setCurrentClass(cpClass[segment.getClassBands().getClassThisInts()[c]]);
  476.                     operandManager.setSuperClass(cpClass[segment.getClassBands().getClassSuperInts()[c]]);
  477.                     final List<ExceptionTableEntry> exceptionTable = new ArrayList<>();
  478.                     if (handlerCount != null) {
  479.                         for (int j = 0; j < handlerCount[i]; j++) {
  480.                             final int handlerClass = handlerClassTypes[i][j] - 1;
  481.                             CPClass cpHandlerClass = null;
  482.                             if (handlerClass != -1) {
  483.                                 // The handlerClass will be null if the
  484.                                 // catch is a finally (that is, the
  485.                                 // exception table catch_type should be 0
  486.                                 cpHandlerClass = segment.getCpBands().cpClassValue(handlerClass);
  487.                             }
  488.                             final ExceptionTableEntry entry = new ExceptionTableEntry(handlerStartPCs[i][j], handlerEndPCs[i][j], handlerCatchPCs[i][j],
  489.                                     cpHandlerClass);
  490.                             exceptionTable.add(entry);
  491.                         }
  492.                     }
  493.                     final CodeAttribute codeAttr = new CodeAttribute(maxStack, maxLocal, methodByteCodePacked[c][m], segment, operandManager, exceptionTable);
  494.                     final List<Attribute> methodAttributesList = methodAttributes[c][m];
  495.                     // Make sure we add the code attribute in the right place
  496.                     int indexForCodeAttr = 0;
  497.                     for (final Attribute attribute : methodAttributesList) {
  498.                         if (!(attribute instanceof NewAttribute) || ((NewAttribute) attribute).getLayoutIndex() >= 15) {
  499.                             break;
  500.                         }
  501.                         indexForCodeAttr++;
  502.                     }
  503.                     methodAttributesList.add(indexForCodeAttr, codeAttr);
  504.                     codeAttr.renumber(codeAttr.byteCodeOffsets);
  505.                     List<Attribute> currentAttributes;
  506.                     if (allCodeHasFlags) {
  507.                         currentAttributes = orderedCodeAttributes.get(i);
  508.                     } else if (codeHasFlags[i]) {
  509.                         currentAttributes = orderedCodeAttributes.get(codeAttributeIndex);
  510.                         codeAttributeIndex++;
  511.                     } else {
  512.                         currentAttributes = Collections.EMPTY_LIST;
  513.                     }
  514.                     for (final Attribute currentAttribute : currentAttributes) {
  515.                         codeAttr.addAttribute(currentAttribute);
  516.                         // Fix up the line numbers if needed
  517.                         if (currentAttribute.hasBCIRenumbering()) {
  518.                             ((BCIRenumberedAttribute) currentAttribute).renumber(codeAttr.byteCodeOffsets);
  519.                         }
  520.                     }
  521.                     i++;
  522.                 }
  523.             }
  524.         }
  525.     }
  526. }
Created with JaCoCo 0.8.12.202403310830