RubyGems - sometsome - Versions diffs - 3.10.46 → 3.10.50.33 - Mend

sometsome 3.10.46 → 3.10.50.33

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (733) hide show

data/lib/proguard4.7/src/proguard/retrace/package.html DELETED

@@ -1,4 +0,0 @@
-<body>
-This package contains the main ReTrace application.
-ReTrace can de-obfuscate stack traces of obfuscated programs.
-</body>

data/lib/proguard4.7/src/proguard/shrink/AnnotationUsageMarker.java DELETED

@@ -1,333 +0,0 @@
-/*
- * ProGuard -- shrinking, optimization, obfuscation, and preverification
- *             of Java bytecode.
- *
- * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-package proguard.shrink;
-import proguard.classfile.*;
-import proguard.classfile.attribute.Attribute;
-import proguard.classfile.attribute.annotation.*;
-import proguard.classfile.attribute.annotation.visitor.*;
-import proguard.classfile.attribute.visitor.AttributeVisitor;
-import proguard.classfile.constant.*;
-import proguard.classfile.constant.visitor.ConstantVisitor;
-import proguard.classfile.util.SimplifiedVisitor;
-import proguard.classfile.visitor.*;
-/**
- * This AttributeVisitor recursively marks all necessary annotation information
- * in the attributes that it visits.
- *
- * @see UsageMarker
- *
- * @author Eric Lafortune
- */
-public class AnnotationUsageMarker
-extends      SimplifiedVisitor
-implements   AttributeVisitor,
-             AnnotationVisitor,
-             ElementValueVisitor,
-             ConstantVisitor,
-             ClassVisitor,
-             MemberVisitor
-{
-    private final UsageMarker usageMarker;
-    // Fields acting as a return parameters for several methods.
-    private boolean attributeUsed;
-    private boolean annotationUsed;
-    private boolean classUsed;
-    private boolean methodUsed;
-    /**
-     * Creates a new AnnotationUsageMarker.
-     * @param usageMarker the usage marker that is used to mark the classes
-     *                    and class members.
-     */
-    public AnnotationUsageMarker(UsageMarker usageMarker)
-    {
-        this.usageMarker = usageMarker;
-    }
-    // Implementations for AttributeVisitor.
-    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
-    public void visitAnyAnnotationsAttribute(Clazz clazz, AnnotationsAttribute annotationsAttribute)
-    {
-        // Mark the necessary annotation information.
-        attributeUsed = false;
-        annotationsAttribute.annotationsAccept(clazz, this);
-        if (attributeUsed)
-        {
-            // We got a positive used flag, so some annotation is being used.
-            // Mark this attribute as being used as well.
-            usageMarker.markAsUsed(annotationsAttribute);
-            markConstant(clazz, annotationsAttribute.u2attributeNameIndex);
-        }
-    }
-    public void visitAnyParameterAnnotationsAttribute(Clazz clazz, Method method, ParameterAnnotationsAttribute parameterAnnotationsAttribute)
-    {
-        // Mark the necessary annotation information.
-        attributeUsed = false;
-        parameterAnnotationsAttribute.annotationsAccept(clazz, method, this);
-        if (attributeUsed)
-        {
-            // We got a positive used flag, so some annotation is being used.
-            // Mark this attribute as being used as well.
-            usageMarker.markAsUsed(parameterAnnotationsAttribute);
-            markConstant(clazz, parameterAnnotationsAttribute.u2attributeNameIndex);
-        }
-    }
-    public void visitAnnotationDefaultAttribute(Clazz clazz, Method method, AnnotationDefaultAttribute annotationDefaultAttribute)
-    {
-        // Mark the necessary annotation information in any annotation elements.
-        annotationDefaultAttribute.defaultValueAccept(clazz, this);
-        // Always mark annotation defaults.
-        usageMarker.markAsUsed(annotationDefaultAttribute);
-        markConstant(clazz, annotationDefaultAttribute.u2attributeNameIndex);
-    }
-    // Implementations for AnnotationVisitor.
-    public void visitAnnotation(Clazz clazz, Annotation annotation)
-    {
-        if (isReferencedClassUsed(annotation))
-        {
-            // Mark the annotation as being used.
-            usageMarker.markAsUsed(annotation);
-            markConstant(clazz, annotation.u2typeIndex);
-            // Mark the necessary element values.
-            annotation.elementValuesAccept(clazz, this);
-            // The return values.
-            annotationUsed = true;
-            attributeUsed  = true;
-        }
-    }
-    // Implementations for ElementValueVisitor.
-    public void visitConstantElementValue(Clazz clazz, Annotation annotation, ConstantElementValue constantElementValue)
-    {
-        if (isReferencedMethodUsed(constantElementValue))
-        {
-            // Mark the element value as being used.
-            usageMarker.markAsUsed(constantElementValue);
-            markConstant(clazz, constantElementValue.u2elementNameIndex);
-            markConstant(clazz, constantElementValue.u2constantValueIndex);
-        }
-    }
-    public void visitEnumConstantElementValue(Clazz clazz, Annotation annotation, EnumConstantElementValue enumConstantElementValue)
-    {
-        if (isReferencedMethodUsed(enumConstantElementValue))
-        {
-            // Check the referenced classes.
-            classUsed = true;
-            enumConstantElementValue.referencedClassesAccept(this);
-            if (classUsed)
-            {
-                // Mark the element value as being used.
-                usageMarker.markAsUsed(enumConstantElementValue);
-                markConstant(clazz, enumConstantElementValue.u2elementNameIndex);
-                markConstant(clazz, enumConstantElementValue.u2typeNameIndex);
-                markConstant(clazz, enumConstantElementValue.u2constantNameIndex);
-            }
-        }
-    }
-    public void visitClassElementValue(Clazz clazz, Annotation annotation, ClassElementValue classElementValue)
-    {
-        if (isReferencedMethodUsed(classElementValue))
-        {
-            // Check the referenced classes.
-            classUsed = true;
-            classElementValue.referencedClassesAccept(this);
-            if (classUsed)
-            {
-                // Mark the element value as being used.
-                usageMarker.markAsUsed(classElementValue);
-                markConstant(clazz, classElementValue.u2elementNameIndex);
-                markConstant(clazz, classElementValue.u2classInfoIndex);
-            }
-        }
-    }
-    public void visitAnnotationElementValue(Clazz clazz, Annotation annotation, AnnotationElementValue annotationElementValue)
-    {
-        if (isReferencedMethodUsed(annotationElementValue))
-        {
-            boolean oldAnnotationUsed = annotationUsed;
-            // Check and mark the contained annotation.
-            annotationUsed = false;
-            annotationElementValue.annotationAccept(clazz, this);
-            if (annotationUsed)
-            {
-                // Mark the element value as being used.
-                usageMarker.markAsUsed(annotationElementValue);
-                markConstant(clazz, annotationElementValue.u2elementNameIndex);
-            }
-            annotationUsed = oldAnnotationUsed;
-        }
-    }
-    public void visitArrayElementValue(Clazz clazz, Annotation annotation, ArrayElementValue arrayElementValue)
-    {
-        if (isReferencedMethodUsed(arrayElementValue))
-        {
-            // Check and mark the contained element values.
-            arrayElementValue.elementValuesAccept(clazz, annotation, this);
-            // Mark the element value as being used.
-            usageMarker.markAsUsed(arrayElementValue);
-            markConstant(clazz, arrayElementValue.u2elementNameIndex);
-        }
-    }
-    // Implementations for ConstantVisitor.
-    public void visitAnyConstant(Clazz clazz, Constant constant)
-    {
-        usageMarker.markAsUsed(constant);
-    }
-    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
-    {
-        classUsed = usageMarker.isUsed(classConstant);
-        // Is the class constant marked as being used?
-        if (!classUsed)
-        {
-            // Check the referenced class.
-            classUsed = true;
-            classConstant.referencedClassAccept(this);
-            // Is the referenced class marked as being used?
-            if (classUsed)
-            {
-                // Mark the class constant and its Utf8 constant.
-                usageMarker.markAsUsed(classConstant);
-                markConstant(clazz, classConstant.u2nameIndex);
-            }
-        }
-    }
-    // Implementations for ClassVisitor.
-    public void visitProgramClass(ProgramClass programClass)
-    {
-        classUsed = usageMarker.isUsed(programClass);
-    }
-    public void visitLibraryClass(LibraryClass libraryClass)
-    {
-        classUsed = true;
-    }
-    // Implementations for MemberVisitor.
-    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
-    {
-        methodUsed = usageMarker.isUsed(programMethod);
-    }
-    public void visitLibraryMethod(LibraryClass LibraryClass, LibraryMethod libraryMethod)
-    {
-        classUsed = true;
-    }
-    // Small utility methods.
-    /**
-     * Returns whether the annotation class has been marked as being used.
-     */
-    private boolean isReferencedClassUsed(Annotation annotation)
-    {
-        // Check if the referenced class is being used.
-        classUsed = true;
-        annotation.referencedClassAccept(this);
-        return classUsed;
-    }
-    /**
-     * Returns whether the annotation method has been marked as being used.
-     */
-    private boolean isReferencedMethodUsed(ElementValue elementValue)
-    {
-        // Check if the referenced method is being used.
-        methodUsed = true;
-        elementValue.referencedMethodAccept(this);
-        return methodUsed;
-    }
-    /**
-     * Marks the specified constant pool entry.
-     */
-    private void markConstant(Clazz clazz, int index)
-    {
-        if (index > 0)
-        {
-            clazz.constantPoolEntryAccept(index, this);
-        }
-    }
-}

data/lib/proguard4.7/src/proguard/shrink/ClassShrinker.java DELETED

@@ -1,458 +0,0 @@
-/*
- * ProGuard -- shrinking, optimization, obfuscation, and preverification
- *             of Java bytecode.
- *
- * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-package proguard.shrink;
-import proguard.classfile.*;
-import proguard.classfile.attribute.*;
-import proguard.classfile.attribute.annotation.*;
-import proguard.classfile.attribute.annotation.visitor.*;
-import proguard.classfile.attribute.visitor.*;
-import proguard.classfile.constant.*;
-import proguard.classfile.editor.*;
-import proguard.classfile.util.*;
-import proguard.classfile.visitor.*;
-import java.util.Arrays;
-/**
- * This ClassVisitor removes constant pool entries, class members, and other
- * class elements that are not marked as being used.
- *
- * @see UsageMarker
- *
- * @author Eric Lafortune
- */
-public class ClassShrinker
-extends      SimplifiedVisitor
-implements   ClassVisitor,
-             MemberVisitor,
-             AttributeVisitor,
-             AnnotationVisitor,
-             ElementValueVisitor
-{
-    private final UsageMarker usageMarker;
-    private       int[]                constantIndexMap     = new int[ClassConstants.TYPICAL_CONSTANT_POOL_SIZE];
-    private final ConstantPoolRemapper constantPoolRemapper = new ConstantPoolRemapper();
-    /**
-     * Creates a new ClassShrinker.
-     * @param usageMarker the usage marker that is used to mark the classes
-     *                    and class members.
-     */
-    public ClassShrinker(UsageMarker usageMarker)
-    {
-        this.usageMarker = usageMarker;
-    }
-    // Implementations for ClassVisitor.
-    public void visitProgramClass(ProgramClass programClass)
-    {
-        // Shrink the arrays for constant pool, interfaces, fields, methods,
-        // and class attributes.
-        programClass.u2interfacesCount =
-            shrinkConstantIndexArray(programClass.constantPool,
-                                     programClass.u2interfaces,
-                                     programClass.u2interfacesCount);
-        // Shrinking the constant pool also sets up an index map.
-        int newConstantPoolCount =
-            shrinkConstantPool(programClass.constantPool,
-                               programClass.u2constantPoolCount);
-        programClass.u2fieldsCount =
-            shrinkArray(programClass.fields,
-                        programClass.u2fieldsCount);
-        programClass.u2methodsCount =
-            shrinkArray(programClass.methods,
-                        programClass.u2methodsCount);
-        programClass.u2attributesCount =
-            shrinkArray(programClass.attributes,
-                        programClass.u2attributesCount);
-        // Compact the remaining fields, methods, and attributes,
-        // and remap their references to the constant pool.
-        programClass.fieldsAccept(this);
-        programClass.methodsAccept(this);
-        programClass.attributesAccept(this);
-        // Remap the references to the constant pool if it has shrunk.
-        if (newConstantPoolCount < programClass.u2constantPoolCount)
-        {
-            programClass.u2constantPoolCount = newConstantPoolCount;
-            // Remap all constant pool references.
-            constantPoolRemapper.setConstantIndexMap(constantIndexMap);
-            constantPoolRemapper.visitProgramClass(programClass);
-        }
-        // Remove the unused interfaces from the class signature.
-        programClass.attributesAccept(new SignatureShrinker());
-        // Compact the extra field pointing to the subclasses of this class.
-        programClass.subClasses =
-            shrinkToNewArray(programClass.subClasses);
-    }
-    public void visitLibraryClass(LibraryClass libraryClass)
-    {
-        // Library classes are left unchanged.
-        // Compact the extra field pointing to the subclasses of this class.
-        libraryClass.subClasses =
-            shrinkToNewArray(libraryClass.subClasses);
-    }
-    // Implementations for MemberVisitor.
-    public void visitProgramMember(ProgramClass programClass, ProgramMember programMember)
-    {
-        // Shrink the attributes array.
-        programMember.u2attributesCount =
-            shrinkArray(programMember.attributes,
-                        programMember.u2attributesCount);
-        // Shrink any attributes.
-        programMember.attributesAccept(programClass, this);
-    }
-    // Implementations for AttributeVisitor.
-    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
-    public void visitBootstrapMethodsAttribute(Clazz clazz, BootstrapMethodsAttribute bootstrapMethodsAttribute)
-    {
-        // Shrink the array of BootstrapMethodInfo objects.
-        bootstrapMethodsAttribute.u2bootstrapMethodsCount =
-            shrinkArray(bootstrapMethodsAttribute.bootstrapMethods,
-                        bootstrapMethodsAttribute.u2bootstrapMethodsCount);
-    }
-    public void visitInnerClassesAttribute(Clazz clazz, InnerClassesAttribute innerClassesAttribute)
-    {
-        // Shrink the array of InnerClassesInfo objects.
-        innerClassesAttribute.u2classesCount =
-            shrinkArray(innerClassesAttribute.classes,
-                        innerClassesAttribute.u2classesCount);
-    }
-    public void visitEnclosingMethodAttribute(Clazz clazz, EnclosingMethodAttribute enclosingMethodAttribute)
-    {
-        // Sometimes, a class is still referenced (apparently as a dummy class),
-        // but its enclosing method is not. Then remove the reference to
-        // the enclosing method.
-        // E.g. the anonymous inner class javax.swing.JList$1 is defined inside
-        // a constructor of javax.swing.JList, but it is also referenced as a
-        // dummy argument in a constructor of javax.swing.JList$ListSelectionHandler.
-        if (enclosingMethodAttribute.referencedMethod != null &&
-            !usageMarker.isUsed(enclosingMethodAttribute.referencedMethod))
-        {
-            enclosingMethodAttribute.u2nameAndTypeIndex = 0;
-            enclosingMethodAttribute.referencedMethod = null;
-        }
-    }
-    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
-    {
-        // Shrink the attributes array.
-        codeAttribute.u2attributesCount =
-            shrinkArray(codeAttribute.attributes,
-                        codeAttribute.u2attributesCount);
-    }
-    public void visitAnyAnnotationsAttribute(Clazz clazz, AnnotationsAttribute annotationsAttribute)
-    {
-        // Shrink the annotations array.
-        annotationsAttribute.u2annotationsCount =
-            shrinkArray(annotationsAttribute.annotations,
-                        annotationsAttribute.u2annotationsCount);
-        // Shrink the annotations themselves.
-        annotationsAttribute.annotationsAccept(clazz, this);
-    }
-    public void visitAnyParameterAnnotationsAttribute(Clazz clazz, Method method, ParameterAnnotationsAttribute parameterAnnotationsAttribute)
-    {
-        // Loop over all parameters.
-        for (int parameterIndex = 0; parameterIndex < parameterAnnotationsAttribute.u2parametersCount; parameterIndex++)
-        {
-            // Shrink the parameter annotations array.
-            parameterAnnotationsAttribute.u2parameterAnnotationsCount[parameterIndex] =
-                shrinkArray(parameterAnnotationsAttribute.parameterAnnotations[parameterIndex],
-                            parameterAnnotationsAttribute.u2parameterAnnotationsCount[parameterIndex]);
-        }
-        // Shrink the annotations themselves.
-        parameterAnnotationsAttribute.annotationsAccept(clazz, method, this);
-    }
-    // Implementations for AnnotationVisitor.
-    public void visitAnnotation(Clazz clazz, Annotation annotation)
-    {
-        // Shrink the element values array.
-        annotation.u2elementValuesCount =
-            shrinkArray(annotation.elementValues,
-                        annotation.u2elementValuesCount);
-        // Shrink the element values themselves.
-        annotation.elementValuesAccept(clazz, this);
-    }
-    /**
-     * This AttributeVisitor updates the Utf8 constants of class signatures,
-     * removing any unused interfaces.
-     */
-    private class SignatureShrinker
-    extends       SimplifiedVisitor
-    implements    AttributeVisitor
-    {
-        public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
-        public void visitSignatureAttribute(Clazz clazz, SignatureAttribute  signatureAttribute)
-        {
-            Clazz[] referencedClasses = signatureAttribute.referencedClasses;
-            if (referencedClasses != null)
-            {
-                // Go over the generic definitions, superclass and implemented interfaces.
-                String signature = clazz.getString(signatureAttribute.u2signatureIndex);
-                InternalTypeEnumeration internalTypeEnumeration =
-                    new InternalTypeEnumeration(signature);
-                StringBuffer newSignatureBuffer = new StringBuffer();
-                int referencedClassIndex    = 0;
-                int newReferencedClassIndex = 0;
-                while (internalTypeEnumeration.hasMoreTypes())
-                {
-                    // Consider the classes referenced by this signature.
-                    String type       = internalTypeEnumeration.nextType();
-                    int    classCount = new DescriptorClassEnumeration(type).classCount();
-                    Clazz referencedClass = referencedClasses[referencedClassIndex];
-                    if (referencedClass == null ||
-                        usageMarker.isUsed(referencedClass))
-                    {
-                        // Append the superclass or interface.
-                        newSignatureBuffer.append(type);
-                        // Copy the referenced classes.
-                        for (int counter = 0; counter < classCount; counter++)
-                        {
-                            referencedClasses[newReferencedClassIndex++] =
-                                referencedClasses[referencedClassIndex++];
-                        }
-                    }
-                    else
-                    {
-                        // Skip the referenced classes.
-                        referencedClassIndex += classCount;
-                    }
-                }
-                if (newReferencedClassIndex < referencedClassIndex)
-                {
-                    // Update the signature.
-                    ((Utf8Constant)((ProgramClass)clazz).constantPool[signatureAttribute.u2signatureIndex]).setString(newSignatureBuffer.toString());
-                    // Clear the unused entries.
-                    while (newReferencedClassIndex < referencedClassIndex)
-                    {
-                        referencedClasses[newReferencedClassIndex++] = null;
-                    }
-                }
-            }
-        }
-    }
-    // Implementations for ElementValueVisitor.
-    public void visitAnyElementValue(Clazz clazz, Annotation annotation, ElementValue elementValue) {}
-    public void visitAnnotationElementValue(Clazz clazz, Annotation annotation, AnnotationElementValue annotationElementValue)
-    {
-        // Shrink the contained annotation.
-        annotationElementValue.annotationAccept(clazz, this);
-    }
-    public void visitArrayElementValue(Clazz clazz, Annotation annotation, ArrayElementValue arrayElementValue)
-    {
-        // Shrink the element values array.
-        arrayElementValue.u2elementValuesCount =
-            shrinkArray(arrayElementValue.elementValues,
-                        arrayElementValue.u2elementValuesCount);
-        // Shrink the element values themselves.
-        arrayElementValue.elementValuesAccept(clazz, annotation, this);
-    }
-    // Small utility methods.
-    /**
-     * Removes all entries that are not marked as being used from the given
-     * constant pool.
-     * @return the new number of entries.
-     */
-    private int shrinkConstantPool(Constant[] constantPool, int length)
-    {
-        if (constantIndexMap.length < length)
-        {
-            constantIndexMap = new int[length];
-        }
-        int     counter = 1;
-        boolean isUsed  = false;
-        // Shift the used constant pool entries together.
-        for (int index = 1; index < length; index++)
-        {
-            constantIndexMap[index] = counter;
-            Constant constant = constantPool[index];
-            // Don't update the flag if this is the second half of a long entry.
-            if (constant != null)
-            {
-                isUsed = usageMarker.isUsed(constant);
-            }
-            if (isUsed)
-            {
-                constantPool[counter++] = constant;
-            }
-        }
-        // Clear the remaining constant pool elements.
-        Arrays.fill(constantPool, counter, length, null);
-        return counter;
-    }
-    /**
-     * Removes all indices that point to unused constant pool entries
-     * from the given array.
-     * @return the new number of indices.
-     */
-    private int shrinkConstantIndexArray(Constant[] constantPool, int[] array, int length)
-    {
-        int counter = 0;
-        // Shift the used objects together.
-        for (int index = 0; index < length; index++)
-        {
-            if (usageMarker.isUsed(constantPool[array[index]]))
-            {
-                array[counter++] = array[index];
-            }
-        }
-        // Clear the remaining array elements.
-        Arrays.fill(array, counter, length, 0);
-        return counter;
-    }
-    /**
-     * Removes all Clazz objects that are not marked as being used
-     * from the given array and returns the remaining objects in a an array
-     * of the right size.
-     * @return the new array.
-     */
-    private Clazz[] shrinkToNewArray(Clazz[] array)
-    {
-        if (array == null)
-        {
-            return null;
-        }
-        // Shrink the given array in-place.
-        int length = shrinkArray(array, array.length);
-        if (length == 0)
-        {
-            return null;
-        }
-        // Return immediately if the array is of right size already.
-        if (length == array.length)
-        {
-            return array;
-        }
-        // Copy the remaining elements into a new array of the right size.
-        Clazz[] newArray = new Clazz[length];
-        System.arraycopy(array, 0, newArray, 0, length);
-        return newArray;
-    }
-    /**
-     * Removes all VisitorAccepter objects that are not marked as being used
-     * from the given array.
-     * @return the new number of VisitorAccepter objects.
-     */
-    private int shrinkArray(VisitorAccepter[] array, int length)
-    {
-        int counter = 0;
-        // Shift the used objects together.
-        for (int index = 0; index < length; index++)
-        {
-            if (usageMarker.isUsed(array[index]))
-            {
-                array[counter++] = array[index];
-            }
-        }
-        // Clear any remaining array elements.
-        if (counter < length)
-        {
-            Arrays.fill(array, counter, length, null);
-        }
-        return counter;
-    }
-}