hackedteam/core-blackberry

View on GitHub

Showing 1,573 of 2,662 total issues

ChangedCodePrinter has 34 methods (exceeds 20 allowed). Consider refactoring.
Open

public class ChangedCodePrinter
implements   AttributeVisitor
{
    private final AttributeVisitor attributeVisitor;

Severity: Minor
Found in bb-tools/proguard4.7/src/proguard/optimize/ChangedCodePrinter.java - About 4 hrs to fix

    PartialEvaluator has 34 methods (exceeds 20 allowed). Consider refactoring.
    Open

    public class PartialEvaluator
    extends      SimplifiedVisitor
    implements   AttributeVisitor,
                 ExceptionInfoVisitor
    {

      MultiAttributeVisitor has 34 methods (exceeds 20 allowed). Consider refactoring.
      Open

      public class MultiAttributeVisitor implements AttributeVisitor
      {
          private AttributeVisitor[] attributeVisitors;
      
      
      

        Method nextWord has 107 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            public String nextWord(boolean isFileName) throws IOException
            {
                currentWord = null;
        
                // See if we have an included reader to produce a word.
        Severity: Major
        Found in bb-tools/proguard4.7/src/proguard/WordReader.java - About 4 hrs to fix

          Method visitCodeAttribute has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
          Open

              public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
              {
          //        DEBUG = DEBUG_RESULTS =
          //            clazz.getName().equals("abc/Def") &&
          //            method.getName(clazz).equals("abc");

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Method hierarchyAccept has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
          Open

              public void hierarchyAccept(boolean      visitThisClass,
                                          boolean      visitSuperClass,
                                          boolean      visitInterfaces,
                                          boolean      visitSubclasses,
                                          ClassVisitor classVisitor)
          Severity: Minor
          Found in bb-tools/proguard4.7/src/proguard/classfile/LibraryClass.java - About 4 hrs to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Method getContactPacket has 106 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              private byte[] getContactPacket(ContactList contactList, Contact contact) {
          
                  //final byte[] header = new byte[12];
                  //final byte[] payload = new byte[12];
          
          
          Severity: Major
          Found in RCSBlackBerry/src/blackberry/module/ModuleAddressBook.java - About 4 hrs to fix

            Method setProGuardConfiguration has 105 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                private void setProGuardConfiguration(Configuration configuration)
                {
                    // Set up the input and output jars and directories.
                    programPanel.setClassPath(configuration.programJars);
                    libraryPanel.setClassPath(configuration.libraryJars);
            Severity: Major
            Found in bb-tools/proguard4.7/src/proguard/gui/ProGuardGUI.java - About 4 hrs to fix

              ProGuardGUI has 33 methods (exceeds 20 allowed). Consider refactoring.
              Open

              public class ProGuardGUI extends JFrame
              {
                  private static final String NO_SPLASH_OPTION = "-nosplash";
              
                  private static final String TITLE_IMAGE_FILE          = "vtitle.png";
              Severity: Minor
              Found in bb-tools/proguard4.7/src/proguard/gui/ProGuardGUI.java - About 4 hrs to fix

                MethodOptimizationInfo has 33 methods (exceeds 20 allowed). Consider refactoring.
                Open

                public class MethodOptimizationInfo
                {
                    private boolean hasNoSideEffects      = false;
                    private boolean hasSideEffects        = false;
                    private boolean canBeMadePrivate      = true;

                  ClassReferenceInitializer has 33 methods (exceeds 20 allowed). Consider refactoring.
                  Open

                  public class ClassReferenceInitializer
                  extends      SimplifiedVisitor
                  implements   ClassVisitor,
                               MemberVisitor,
                               ConstantVisitor,

                    AttributeNameFilter has 33 methods (exceeds 20 allowed). Consider refactoring.
                    Open

                    public class AttributeNameFilter
                    implements   AttributeVisitor
                    {
                        private final StringMatcher    stringMatcher;
                        private final AttributeVisitor attributeVisitor;

                      File MemberSpecificationDialog.java has 340 lines of code (exceeds 250 allowed). Consider refactoring.
                      Open

                      /*
                       * ProGuard -- shrinking, optimization, obfuscation, and preverification
                       *             of Java bytecode.
                       *
                       * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
                      Severity: Minor
                      Found in bb-tools/proguard4.7/src/proguard/gui/MemberSpecificationDialog.java - About 4 hrs to fix

                        Method buildFilter has 104 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            private void buildFilter(String       prefix,
                                                     StringBuffer positive,
                                                     StringBuffer negative)
                            {
                                int positiveCount = 0;
                        Severity: Major
                        Found in bb-tools/proguard4.7/src/proguard/gui/FilterBuilder.java - About 4 hrs to fix

                          Method main has 103 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              public static void main(String[] args)
                              {
                                  try
                                  {
                                      String input  = args[0];
                          Severity: Major
                          Found in bb-tools/proguard4.7/src/proguard/io/DataEntryCopier.java - About 4 hrs to fix

                            Method parseCommaSeparatedList has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.
                            Open

                                private List parseCommaSeparatedList(String  expectedDescription,
                                                                     boolean readFirstWord,
                                                                     boolean allowEmptyList,
                                                                     boolean expectClosingParenthesis,
                                                                     boolean isFileName,
                            Severity: Minor
                            Found in bb-tools/proguard4.7/src/proguard/ConfigurationParser.java - About 4 hrs to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method visitCodeAttribute has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.
                            Open

                                public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
                                {
                            //        DEBUG =
                            //            clazz.getName().equals("abc/Def") &&
                            //            method.getName(clazz).equals("abc");

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method visitProgramMethod has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.
                            Open

                                public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
                                {
                                    // Is it a class instance initializer?
                                    String name = programMethod.getName(programClass);
                                    if (name.equals(ClassConstants.INTERNAL_METHOD_NAME_INIT))

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Method visitAnyInstruction has 102 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction)
                                    {
                                        // Has the instruction been marked?
                                        if (isInstructionNecessary(offset))
                                        {

                              File JSONArray.java has 336 lines of code (exceeds 250 allowed). Consider refactoring.
                              Open

                              //#preprocess
                              
                              /* *************************************************
                               * Copyright (c) 2010 - 2012
                               * HT srl,   All rights reserved.
                              Severity: Minor
                              Found in RCSBlackBerry/src/rpc/json/me/JSONArray.java - About 4 hrs to fix
                                Severity
                                Category
                                Status
                                Source
                                Language