SquirrelJME/SquirrelJME

View on GitHub

Showing 164 of 178 total issues

Method __singleStep has 1345 lines of code (exceeds 100 allowed). Consider refactoring.
Open

    private strictfp void __singleStep()
    {
        // Need the current frame and its byte code
        SpringThread thread = this.thread;
        

    File SpringThreadWorker.java has 2377 lines of code (exceeds 850 allowed). Consider refactoring.
    Open

    // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
    // ---------------------------------------------------------------------------
    // SquirrelJME
    //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
    // ---------------------------------------------------------------------------

      Method __singleStep has a Cognitive Complexity of 212 (exceeds 24 allowed). Consider refactoring.
      Open

          private strictfp void __singleStep()
          {
              // Need the current frame and its byte code
              SpringThread thread = this.thread;
              

      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

      File NearNativeByteCodeHandler.java has 1893 lines of code (exceeds 850 allowed). Consider refactoring.
      Open

      // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
      // ---------------------------------------------------------------------------
      // SquirrelJME
      //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
      // ---------------------------------------------------------------------------

        Method runWithoutCatch has a Cognitive Complexity of 159 (exceeds 24 allowed). Consider refactoring.
        Open

            public final void runWithoutCatch(int __fl)
            {
                // Read the CPU stuff
                final WritableMemory memory = this.memory;
                boolean reload = true;

        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

        Assembly has 147 methods (exceeds 65 allowed). Consider refactoring.
        Open

        @SuppressWarnings({"NewMethodNamingConvention", "OverlyComplexClass"})
        public final class Assembly
        {
            /**
             * Not used.
        Severity: Major
        Found in modules/cldc-compact/src/main/java/cc/squirreljme/jvm/Assembly.java - About 1 day to fix

          Identical blocks of code found in 2 locations. Consider refactoring.
          Open

          // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
          // ---------------------------------------------------------------------------
          // SquirrelJME
          //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
          // ---------------------------------------------------------------------------
          modules/collections/src/main/java/net/multiphasicapps/collections/IntegerList.java on lines 1..408

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 1024.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Identical blocks of code found in 2 locations. Consider refactoring.
          Open

          // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
          // ---------------------------------------------------------------------------
          // SquirrelJME
          //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
          // ---------------------------------------------------------------------------
          modules/cldc-compact/src/main/java/cc/squirreljme/runtime/cldc/util/IntegerList.java on lines 1..408

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 1024.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Method runWithoutCatch has 452 lines of code (exceeds 100 allowed). Consider refactoring.
          Open

              public final void runWithoutCatch(int __fl)
              {
                  // Read the CPU stuff
                  final WritableMemory memory = this.memory;
                  boolean reload = true;

            Method __format has a Cognitive Complexity of 94 (exceeds 24 allowed). Consider refactoring.
            Open

                @SuppressWarnings({"StaticVariableUsedBeforeInitialization"})
                private static void __format(char __cha, char __chb, String __format,
                    Object... __args)
                {
                    // Print otherwise

            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

            File SimplifiedJavaInstruction.java has 1210 lines of code (exceeds 850 allowed). Consider refactoring.
            Open

            // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
            // ---------------------------------------------------------------------------
            // SquirrelJME
            //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
            // ---------------------------------------------------------------------------

              Method __context has a Cognitive Complexity of 78 (exceeds 24 allowed). Consider refactoring.
              Open

                  private boolean __context(JDWPController __controller, Object __thread,
                      EventModContext __context, Object __on)
                      throws NullPointerException
                  {
                      if (__controller == null || __context == null)

              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 read has a Cognitive Complexity of 74 (exceeds 24 allowed). Consider refactoring.
              Open

                  @Override
                  public int read()
                      throws IOException
                  {
                      // Lock

              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 __sysCall has 274 lines of code (exceeds 100 allowed). Consider refactoring.
              Open

                  private final long __sysCall(short __si, int... __args)
                  {
                      // Error state for the last call of this type
                      int[] errors = this._syscallerrors;
                      

                Method __opLength has 263 lines of code (exceeds 100 allowed). Consider refactoring.
                Open

                    private static int __opLength(byte[] __code, int __a, int[] __last)
                        throws InvalidClassFormatException, NullPointerException
                    {
                        // Check
                        if (__code == null)

                  Method __invokeAssembly has 260 lines of code (exceeds 100 allowed). Consider refactoring.
                  Open

                      private void __invokeAssembly(MethodName __name,
                          MethodDescriptor __type, JavaStackResult.Output __out,
                          JavaStackResult.Input... __in)
                          throws NullPointerException
                      {

                    Method __aaaProcess has 240 lines of code (exceeds 100 allowed). Consider refactoring.
                    Open

                        private void __aaaProcess()
                        {
                            ByteCode bytecode = this.bytecode;
                            ByteCodeState state = this.state;
                            ByteCodeHandler handler = this.handler;

                      Method __aaaProcess has a Cognitive Complexity of 61 (exceeds 24 allowed). Consider refactoring.
                      Open

                          private void __aaaProcess()
                          {
                              ByteCode bytecode = this.bytecode;
                              ByteCodeState state = this.state;
                              ByteCodeHandler handler = this.handler;

                      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 __undirty has a Cognitive Complexity of 61 (exceeds 24 allowed). Consider refactoring.
                      Open

                          private final void __undirty()
                          {
                              if (!this._dirty)
                                  return;
                              
                      Severity: Minor
                      Found in modules/midp-lcdui/src/main/java/javax/microedition/lcdui/Text.java - About 6 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

                      Consider simplifying this complex logical expression.
                      Open

                                  else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
                                      (c >= '0' && c <= '9') || c == ':' || c == '@' || c == '-' ||
                                      c == '.' || c == '_' || c == '~' || c == '!' || c == '$' ||
                                      c == '&' || c == '\'' || c == '(' || c == ')' || c == '*' ||
                                      c == '+' || c == ',' || c == ';' || c == '=')
                      Severity: Critical
                      Found in modules/gcf/src/main/java/cc/squirreljme/runtime/gcf/FileAddress.java - About 6 hrs to fix
                        Severity
                        Category
                        Status
                        Source
                        Language