SquirrelJME/SquirrelJME

View on GitHub

Showing 110 of 158 total issues

Method __singleStep has 1258 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 2174 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>

      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 __singleStep has a Cognitive Complexity of 182 (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

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

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

          Method runWithoutCatch has a Cognitive Complexity of 160 (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

          Method runWithoutCatch has 453 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;

            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 __sysCall has 307 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 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 __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 __format has a Cognitive Complexity of 67 (exceeds 24 allowed). Consider refactoring.
                  Open

                      @SuppressWarnings({"StaticVariableUsedBeforeInitialization"})
                      private static void __format(char __cha, char __chb, String __format,
                          Object... __args)
                      {
                          // Print quickly and stop because this may infinite loop

                  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 __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
                      {

                    File NativeCPU.java has 1043 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 __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

                          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)

                            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)
                              Severity
                              Category
                              Status
                              Source
                              Language