SquirrelJME/SquirrelJME

View on GitHub

Showing 121 of 1,004 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");

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

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

      public final class NearNativeByteCodeHandler
          implements ByteCodeHandler
      {
          /** The jvm functions class. */
          public static final ClassName JVMFUNC_CLASS =

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

            @Override
            public final String toString()
            {
                Reference<String> ref = this._string;
                String rv;

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

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

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

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

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

                    public final String toAtLineString()
                    {
                        Reference<String> ref = this._stringatl;
                        String rv;
                        

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

                    public static void main(String... __args)
                    {
                        // Poke the VM to initialize some probably important parts of it
                        Poking.poke();
                        

                  Method minimize has 116 lines of code (exceeds 100 allowed). Consider refactoring.
                  Open

                      public static final void minimize(OutputStream __os, String __boot,
                          String[] __initcp, String __mainbc, boolean __ismid,
                          VMClassLibrary... __libs)
                          throws IOException, NullPointerException
                      {

                    Method paint has 116 lines of code (exceeds 100 allowed). Consider refactoring.
                    Open

                        public final void paint(Graphics __g, int __x, int __y, int __w, int __h)
                        {
                            // Get display details
                            int dw = this.width,
                                dh = this.height;
                      Severity
                      Category
                      Status
                      Source
                      Language