SquirrelJME/SquirrelJME

View on GitHub

Showing 110 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 -*-
    // ---------------------------------------------------------------------------
    // Multi-Phasic Applications: SquirrelJME
    //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
    //     Copyright (C) Multi-Phasic Applications <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 -*-
      // ---------------------------------------------------------------------------
      // Multi-Phasic Applications: 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

          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 -*-
            // ---------------------------------------------------------------------------
            // Multi-Phasic Applications: 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 __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

                      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

                      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

                        Method toString has 223 lines of code (exceeds 100 allowed). Consider refactoring.
                        Open

                            @SuppressWarnings("MagicNumber")
                            public static String toString(int __code)
                            {
                                // Wide codes
                                switch (__code & 0xFFFF)

                          Method deserialize has 223 lines of code (exceeds 100 allowed). Consider refactoring.
                          Open

                              public static Object deserialize(Graphics __g, GraphicsFunction __func,
                                  Object... __args)
                                  throws IllegalArgumentException, NullPointerException
                              {
                                  if (__g == null || __func == null)
                            Severity
                            Category
                            Status
                            Source
                            Language