SquirrelJME/SquirrelJME

View on GitHub

Showing 122 of 1,009 total issues

Method __singleStep has 1260 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 2177 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 1884 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;

            Method serialize has a Cognitive Complexity of 105 (exceeds 24 allowed). Consider refactoring.
            Open

                public static String serialize(Object __o)
                {
                    // Null
                    if (__o == null)
                        return "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

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

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

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

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

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

                            private final 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 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