SquirrelJME/SquirrelJME

View on GitHub

Showing 110 of 178 total issues

Method __process has 145 lines of code (exceeds 100 allowed). Consider refactoring.
Open

    private final void __process(OutputStream __sout)
        throws IOException, NullPointerException
    {
        if (__sout == null)
            throw new NullPointerException("NARG");

    Method infoPointer has a Cognitive Complexity of 39 (exceeds 24 allowed). Consider refactoring.
    Open

        public final int infoPointer()
        {
            // If it has already been initialized use it
            int rv = this._classdata;
            if (rv >= 0)

    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 JavaStackState.java has 879 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>
    // ---------------------------------------------------------------------------

      NearNativeByteCodeHandler has 69 methods (exceeds 65 allowed). Consider refactoring.
      Open

      public final class NearNativeByteCodeHandler
          implements ByteCodeHandler
      {
          /** The jvm functions class. */
          @Deprecated

        Method nextEntry has a Cognitive Complexity of 38 (exceeds 24 allowed). Consider refactoring.
        Open

            public ZipStreamEntry nextEntry()
                throws IOException
            {
                // {@squirreljme.error BF0z An entry is currently being read, it
                // must first be closed.}

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

            @ImplementationNote("Source: http://www.netlib.org/fdlibm/e_sqrt.c")
            public static double sqrt(double __v)
            {
                double z;
                int uur, uut1, uus1, uuix1, uuq1;

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

            public static char byteToChar(int __b)
                throws IllegalArgumentException
            {
                // {@squirreljme.error BF01 Byte index is not within bounds.
                // (The byte)}
        Severity: Major
        Found in modules/zip/src/main/java/net/multiphasicapps/zip/IBM437CodePage.java - About 2 hrs to fix

          Method read has a Cognitive Complexity of 36 (exceeds 24 allowed). Consider refactoring.
          Open

              @Override
              public int read(byte[] __b, int __o, int __l)
                  throws IndexOutOfBoundsException, IOException, NullPointerException
              {
                  // Check
          Severity: Minor
          Found in modules/io/src/main/java/net/multiphasicapps/io/ZLibDecompressor.java - About 2 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 parse has a Cognitive Complexity of 36 (exceeds 24 allowed). Consider refactoring.
          Open

              public Image parse()
                  throws IOException
              {
                  DataInputStream in = this.in;
                  

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

              private byte[] __translateCode(NativeCode __rc)
                  throws IOException, NullPointerException
              {
                  if (__rc == null)
                      throw new NullPointerException("NARG");

            Method read has 128 lines of code (exceeds 100 allowed). Consider refactoring.
            Open

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

              Method equals has a Cognitive Complexity of 35 (exceeds 24 allowed). Consider refactoring.
              Open

                  @Override
                  @ImplementationNote("This method considers if the source and target " +
                      "lists are RandomAccess, for more optimized comparison.")
                  public boolean equals(Object __o)
                  {
              Severity: Minor
              Found in modules/cldc-compact/src/main/java/java/util/AbstractList.java - About 2 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 __undirty has 125 lines of code (exceeds 100 allowed). Consider refactoring.
              Open

                  private final void __undirty()
                  {
                      if (!this._dirty)
                          return;
                      
              Severity: Major
              Found in modules/midp-lcdui/src/main/java/javax/microedition/lcdui/Text.java - About 2 hrs to fix

                Method __sysCall has a Cognitive Complexity of 34 (exceeds 24 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;
                        

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

                    private void __update(JavaStackResult __jsr)
                        throws NullPointerException
                    {
                        if (__jsr == null)
                            throw new NullPointerException("NARG");

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

                    @Override
                    public final void run()
                    {
                        List<TimerTask> tasks = this._tasks;
                        
                Severity: Minor
                Found in modules/cldc-compact/src/main/java/java/util/__TimerThread__.java - About 1 hr 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 asVMObject has a Cognitive Complexity of 33 (exceeds 24 allowed). Consider refactoring.
                Open

                    public final Object asVMObject(Object __in, boolean __noclassres)
                    {
                        // Null is converted to null
                        if (__in == null)
                            return SpringNullObject.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 parse has a Cognitive Complexity of 32 (exceeds 24 allowed). Consider refactoring.
                Open

                    public static final HTTPResponseHeader parse(InputStream __in)
                        throws IOException, NullPointerException
                    {
                        if (__in == null)
                            throw new NullPointerException("NARG");

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

                    final void __drawText(Text __t, int __x, int __y, int __anchor)
                        throws NullPointerException
                    {
                        if (__t == null)
                            throw new NullPointerException("NARG");

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

                    private final void __process(OutputStream __sout)
                        throws IOException, NullPointerException
                    {
                        if (__sout == null)
                            throw new NullPointerException("NARG");

                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

                Severity
                Category
                Status
                Source
                Language