zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java

Summary

Maintainability
F
2 mos
Test Coverage

Method jjMoveNfa_1 has a Cognitive Complexity of 413 (exceeds 5 allowed). Consider refactoring.
Open

private int jjMoveNfa_1(int startState, int curPos)
{
   int startsAt = 0;
   jjnewStateCnt = 30;
   int i = 1;

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 jjMoveNfa_2 has a Cognitive Complexity of 413 (exceeds 5 allowed). Consider refactoring.
Open

private int jjMoveNfa_2(int startState, int curPos)
{
   int startsAt = 0;
   jjnewStateCnt = 30;
   int i = 1;

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 ELParserTokenManager.java has 2104 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/* Generated By:JJTree&JavaCC: Do not edit this line. ELParserTokenManager.java */
package org.zkoss.zel.impl.parser;
import java.io.StringReader;

import org.zkoss.zel.ELException;
Severity: Major
Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 5 days to fix

    Method jjMoveNfa_0 has a Cognitive Complexity of 195 (exceeds 5 allowed). Consider refactoring.
    Open

    private int jjMoveNfa_0(int startState, int curPos)
    {
       int startsAt = 0;
       jjnewStateCnt = 8;
       int i = 1;
    Severity: Minor
    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 3 days 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 jjMoveNfa_1 has 335 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    private int jjMoveNfa_1(int startState, int curPos)
    {
       int startsAt = 0;
       jjnewStateCnt = 30;
       int i = 1;
    Severity: Major
    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 1 day to fix

      Method jjMoveNfa_2 has 335 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      private int jjMoveNfa_2(int startState, int curPos)
      {
         int startsAt = 0;
         jjnewStateCnt = 30;
         int i = 1;
      Severity: Major
      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 1 day to fix

        Method getNextToken has a Cognitive Complexity of 70 (exceeds 5 allowed). Consider refactoring.
        Open

        public Token getNextToken()
        {
          Token matchedToken;
          int curPos = 0;
        
        Severity: Minor
        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 1 day 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 jjMoveNfa_0 has 178 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        private int jjMoveNfa_0(int startState, int curPos)
        {
           int startsAt = 0;
           jjnewStateCnt = 8;
           int i = 1;
        Severity: Major
        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 7 hrs to fix

          ELParserTokenManager has 48 methods (exceeds 20 allowed). Consider refactoring.
          Open

          @SuppressWarnings("all") // Ignore warnings in generated code
          public class ELParserTokenManager implements ELParserConstants
          {
          java.util.Deque<Integer> deque = new java.util.ArrayDeque<Integer>();
          
          Severity: Minor
          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 6 hrs to fix

            Method jjStopStringLiteralDfa_1 has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
            Open

            private final int jjStopStringLiteralDfa_1(int pos, long active0)
            {
               switch (pos)
               {
                  case 0:
            Severity: Minor
            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 4 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 jjStopStringLiteralDfa_2 has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
            Open

            private final int jjStopStringLiteralDfa_2(int pos, long active0)
            {
               switch (pos)
               {
                  case 0:
            Severity: Minor
            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 4 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 getNextToken has 94 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            public Token getNextToken()
            {
              Token matchedToken;
              int curPos = 0;
            
            Severity: Major
            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 3 hrs to fix

              Method jjMoveStringLiteralDfa1_1 has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
              Open

              private int jjMoveStringLiteralDfa1_1(long active0)
              {
                 try { curChar = input_stream.readChar(); }
                 catch(java.io.IOException e) {
                    jjStopStringLiteralDfa_1(0, active0);
              Severity: Minor
              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 3 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 jjMoveStringLiteralDfa1_2 has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
              Open

              private int jjMoveStringLiteralDfa1_2(long active0)
              {
                 try { curChar = input_stream.readChar(); }
                 catch(java.io.IOException e) {
                    jjStopStringLiteralDfa_2(0, active0);
              Severity: Minor
              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 3 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 jjStopStringLiteralDfa_2 has 86 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              private final int jjStopStringLiteralDfa_2(int pos, long active0)
              {
                 switch (pos)
                 {
                    case 0:
              Severity: Major
              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 3 hrs to fix

                Method jjStopStringLiteralDfa_1 has 86 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                private final int jjStopStringLiteralDfa_1(int pos, long active0)
                {
                   switch (pos)
                   {
                      case 0:
                Severity: Major
                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 3 hrs to fix

                  Method jjMoveStringLiteralDfa0_2 has 77 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  private int jjMoveStringLiteralDfa0_2()
                  {
                     switch(curChar)
                     {
                        case 33:
                  Severity: Major
                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 3 hrs to fix

                    Method jjMoveStringLiteralDfa0_1 has 77 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    private int jjMoveStringLiteralDfa0_1()
                    {
                       switch(curChar)
                       {
                          case 33:
                    Severity: Major
                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 3 hrs to fix

                      Method jjMoveStringLiteralDfa1_1 has 69 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      private int jjMoveStringLiteralDfa1_1(long active0)
                      {
                         try { curChar = input_stream.readChar(); }
                         catch(java.io.IOException e) {
                            jjStopStringLiteralDfa_1(0, active0);
                      Severity: Major
                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 2 hrs to fix

                        Method jjMoveStringLiteralDfa1_2 has 69 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        private int jjMoveStringLiteralDfa1_2(long active0)
                        {
                           try { curChar = input_stream.readChar(); }
                           catch(java.io.IOException e) {
                              jjStopStringLiteralDfa_2(0, active0);
                        Severity: Major
                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 2 hrs to fix

                          Method jjMoveStringLiteralDfa2_1 has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          private int jjMoveStringLiteralDfa2_1(long old0, long active0)
                          {
                             if (((active0 &= old0)) == 0L)
                                return jjStartNfa_1(0, old0);
                             try { curChar = input_stream.readChar(); }

                            Method jjMoveStringLiteralDfa2_2 has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            private int jjMoveStringLiteralDfa2_2(long old0, long active0)
                            {
                               if (((active0 &= old0)) == 0L)
                                  return jjStartNfa_2(0, old0);
                               try { curChar = input_stream.readChar(); }

                              Method jjMoveStringLiteralDfa2_1 has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                              Open

                              private int jjMoveStringLiteralDfa2_1(long old0, long active0)
                              {
                                 if (((active0 &= old0)) == 0L)
                                    return jjStartNfa_1(0, old0);
                                 try { curChar = input_stream.readChar(); }

                              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 jjMoveStringLiteralDfa2_2 has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                              Open

                              private int jjMoveStringLiteralDfa2_2(long old0, long active0)
                              {
                                 if (((active0 &= old0)) == 0L)
                                    return jjStartNfa_2(0, old0);
                                 try { curChar = input_stream.readChar(); }

                              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

                              Avoid deeply nested control flow statements.
                              Open

                                                   if (kind > 56)
                                                      kind = 56;
                              Severity: Major
                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 45 mins to fix

                                Avoid deeply nested control flow statements.
                                Open

                                                     if (kind > 1)
                                                        kind = 1;
                                Severity: Major
                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 45 mins to fix

                                  Avoid deeply nested control flow statements.
                                  Open

                                                       if (kind > 56)
                                                          kind = 56;
                                  Severity: Major
                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 45 mins to fix

                                    Avoid deeply nested control flow statements.
                                    Open

                                                         if (kind > 57)
                                                            kind = 57;
                                    Severity: Major
                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 45 mins to fix

                                      Avoid deeply nested control flow statements.
                                      Open

                                                           if (kind > 10)
                                                              kind = 10;
                                      Severity: Major
                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 45 mins to fix

                                        Avoid deeply nested control flow statements.
                                        Open

                                                             if (kind > 10)
                                                                kind = 10;
                                        Severity: Major
                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 45 mins to fix

                                          Avoid deeply nested control flow statements.
                                          Open

                                                               if (kind > 57)
                                                                  kind = 57;
                                          Severity: Major
                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 45 mins to fix

                                            Method jjCanMove_0 has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                            Open

                                            private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
                                            Severity: Minor
                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 35 mins to fix

                                              Method jjCanMove_1 has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                              Open

                                              private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
                                              Severity: Minor
                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 35 mins to fix

                                                Method jjMoveStringLiteralDfa4_2 has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                private int jjMoveStringLiteralDfa4_2(long old0, long active0)
                                                {
                                                   if (((active0 &= old0)) == 0L)
                                                      return jjStartNfa_2(2, old0);
                                                   try { curChar = input_stream.readChar(); }
                                                Severity: Minor
                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 35 mins 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 jjMoveStringLiteralDfa3_1 has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                private int jjMoveStringLiteralDfa3_1(long old0, long active0)
                                                {
                                                   if (((active0 &= old0)) == 0L)
                                                      return jjStartNfa_1(1, old0);
                                                   try { curChar = input_stream.readChar(); }
                                                Severity: Minor
                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 35 mins 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 jjMoveStringLiteralDfa3_2 has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                private int jjMoveStringLiteralDfa3_2(long old0, long active0)
                                                {
                                                   if (((active0 &= old0)) == 0L)
                                                      return jjStartNfa_2(1, old0);
                                                   try { curChar = input_stream.readChar(); }
                                                Severity: Minor
                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 35 mins 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 jjMoveStringLiteralDfa4_1 has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                private int jjMoveStringLiteralDfa4_1(long old0, long active0)
                                                {
                                                   if (((active0 &= old0)) == 0L)
                                                      return jjStartNfa_1(2, old0);
                                                   try { curChar = input_stream.readChar(); }
                                                Severity: Minor
                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 35 mins 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

                                                Avoid too many return statements within this method.
                                                Open

                                                            return 30;
                                                Severity: Major
                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                  Avoid too many return statements within this method.
                                                  Open

                                                              return jjStartNfaWithStates_1(1, 34, 30);
                                                  Severity: Major
                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                    Avoid too many return statements within this method.
                                                    Open

                                                             return jjMoveStringLiteralDfa1_2(0x20000000L);
                                                    Severity: Major
                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                      Avoid too many return statements within this method.
                                                      Open

                                                                  return jjStartNfaWithStates_2(1, 26, 30);
                                                      Severity: Major
                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                        Avoid too many return statements within this method.
                                                        Open

                                                                    return jjStartNfaWithStates_2(2, 38, 30);
                                                        Severity: Major
                                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                          Avoid too many return statements within this method.
                                                          Open

                                                                      return jjStartNfaWithStates_2(2, 50, 30);
                                                          Severity: Major
                                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                            Avoid too many return statements within this method.
                                                            Open

                                                               return jjStartNfa_2(2, active0);
                                                            Severity: Major
                                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                              Avoid too many return statements within this method.
                                                              Open

                                                                 return jjStartNfa_2(3, active0);
                                                              Severity: Major
                                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                Avoid too many return statements within this method.
                                                                Open

                                                                         return jjMoveNfa_1(0, 0);
                                                                Severity: Major
                                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                  Avoid too many return statements within this method.
                                                                  Open

                                                                              return 30;
                                                                  Severity: Major
                                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                    Avoid too many return statements within this method.
                                                                    Open

                                                                                return 30;
                                                                    Severity: Major
                                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                      Avoid too many return statements within this method.
                                                                      Open

                                                                               return -1;
                                                                      Severity: Major
                                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                        Avoid too many return statements within this method.
                                                                        Open

                                                                                    return jjStopAtPos(1, 41);
                                                                        Severity: Major
                                                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                          Avoid too many return statements within this method.
                                                                          Open

                                                                                      return 30;
                                                                          Severity: Major
                                                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                            Avoid too many return statements within this method.
                                                                            Open

                                                                                        return jjStartNfaWithStates_1(1, 28, 30);
                                                                            Severity: Major
                                                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                              Avoid too many return statements within this method.
                                                                              Open

                                                                                          return 30;
                                                                              Severity: Major
                                                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                Avoid too many return statements within this method.
                                                                                Open

                                                                                         return -1;
                                                                                Severity: Major
                                                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                  Avoid too many return statements within this method.
                                                                                  Open

                                                                                              return 30;
                                                                                  Severity: Major
                                                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                    Avoid too many return statements within this method.
                                                                                    Open

                                                                                                return jjStopAtPos(1, 29);
                                                                                    Severity: Major
                                                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                      Avoid too many return statements within this method.
                                                                                      Open

                                                                                               return jjMoveNfa_2(0, 0);
                                                                                      Severity: Major
                                                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                        Avoid too many return statements within this method.
                                                                                        Open

                                                                                                    return jjStartNfaWithStates_2(1, 36, 30);
                                                                                        Severity: Major
                                                                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                          Avoid too many return statements within this method.
                                                                                          Open

                                                                                                      return jjStartNfaWithStates_2(1, 32, 30);
                                                                                          Severity: Major
                                                                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                            Avoid too many return statements within this method.
                                                                                            Open

                                                                                                        return jjStartNfaWithStates_2(1, 42, 30);
                                                                                            Severity: Major
                                                                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                              Avoid too many return statements within this method.
                                                                                              Open

                                                                                                          return 30;
                                                                                              Severity: Major
                                                                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                Avoid too many return statements within this method.
                                                                                                Open

                                                                                                         return -1;
                                                                                                Severity: Major
                                                                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                  Avoid too many return statements within this method.
                                                                                                  Open

                                                                                                              return 30;
                                                                                                  Severity: Major
                                                                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                    Avoid too many return statements within this method.
                                                                                                    Open

                                                                                                                return jjStopAtPos(1, 55);
                                                                                                    Severity: Major
                                                                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                      Avoid too many return statements within this method.
                                                                                                      Open

                                                                                                               return jjMoveStringLiteralDfa2_2(active0, 0x4000L);
                                                                                                      Severity: Major
                                                                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                        Avoid too many return statements within this method.
                                                                                                        Open

                                                                                                                    return 30;
                                                                                                        Severity: Major
                                                                                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                          Avoid too many return statements within this method.
                                                                                                          Open

                                                                                                                      return 30;
                                                                                                          Severity: Major
                                                                                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                            Avoid too many return statements within this method.
                                                                                                            Open

                                                                                                               return jjStartNfa_1(1, active0);
                                                                                                            Severity: Major
                                                                                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                              Avoid too many return statements within this method.
                                                                                                              Open

                                                                                                                          return 30;
                                                                                                              Severity: Major
                                                                                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                Avoid too many return statements within this method.
                                                                                                                Open

                                                                                                                            return jjStartNfaWithStates_2(1, 30, 30);
                                                                                                                Severity: Major
                                                                                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                  Avoid too many return statements within this method.
                                                                                                                  Open

                                                                                                                           return -1;
                                                                                                                  Severity: Major
                                                                                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                    Avoid too many return statements within this method.
                                                                                                                    Open

                                                                                                                             return jjMoveStringLiteralDfa1_1(0x20000000L);
                                                                                                                    Severity: Major
                                                                                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                      Avoid too many return statements within this method.
                                                                                                                      Open

                                                                                                                                  return jjStopAtPos(1, 33);
                                                                                                                      Severity: Major
                                                                                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                        Avoid too many return statements within this method.
                                                                                                                        Open

                                                                                                                                 return -1;
                                                                                                                        Severity: Major
                                                                                                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                          Avoid too many return statements within this method.
                                                                                                                          Open

                                                                                                                                   return -1;
                                                                                                                          Severity: Major
                                                                                                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                            Avoid too many return statements within this method.
                                                                                                                            Open

                                                                                                                                     return -1;
                                                                                                                            Severity: Major
                                                                                                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                              Avoid too many return statements within this method.
                                                                                                                              Open

                                                                                                                                       return jjMoveStringLiteralDfa1_1(0x200000000L);
                                                                                                                              Severity: Major
                                                                                                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                Avoid too many return statements within this method.
                                                                                                                                Open

                                                                                                                                            return jjStartNfaWithStates_1(1, 36, 30);
                                                                                                                                Severity: Major
                                                                                                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                  Avoid too many return statements within this method.
                                                                                                                                  Open

                                                                                                                                           return -1;
                                                                                                                                  Severity: Major
                                                                                                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                    Avoid too many return statements within this method.
                                                                                                                                    Open

                                                                                                                                                return 30;
                                                                                                                                    Severity: Major
                                                                                                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                      Avoid too many return statements within this method.
                                                                                                                                      Open

                                                                                                                                               return -1;
                                                                                                                                      Severity: Major
                                                                                                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                        Avoid too many return statements within this method.
                                                                                                                                        Open

                                                                                                                                                 return -1;
                                                                                                                                        Severity: Major
                                                                                                                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                          Avoid too many return statements within this method.
                                                                                                                                          Open

                                                                                                                                                   return -1;
                                                                                                                                          Severity: Major
                                                                                                                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                            Avoid too many return statements within this method.
                                                                                                                                            Open

                                                                                                                                                        return 30;
                                                                                                                                            Severity: Major
                                                                                                                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                              Avoid too many return statements within this method.
                                                                                                                                              Open

                                                                                                                                                 return jjStartNfa_2(0, active0);
                                                                                                                                              Severity: Major
                                                                                                                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                Avoid too many return statements within this method.
                                                                                                                                                Open

                                                                                                                                                         return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
                                                                                                                                                Severity: Major
                                                                                                                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                  Avoid too many return statements within this method.
                                                                                                                                                  Open

                                                                                                                                                           return -1;
                                                                                                                                                  Severity: Major
                                                                                                                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                    Avoid too many return statements within this method.
                                                                                                                                                    Open

                                                                                                                                                                return 30;
                                                                                                                                                    Severity: Major
                                                                                                                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                      Avoid too many return statements within this method.
                                                                                                                                                      Open

                                                                                                                                                               return -1;
                                                                                                                                                      Severity: Major
                                                                                                                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                        Avoid too many return statements within this method.
                                                                                                                                                        Open

                                                                                                                                                                 return -1;
                                                                                                                                                        Severity: Major
                                                                                                                                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                          Avoid too many return statements within this method.
                                                                                                                                                          Open

                                                                                                                                                                      return 30;
                                                                                                                                                          Severity: Major
                                                                                                                                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                            Avoid too many return statements within this method.
                                                                                                                                                            Open

                                                                                                                                                                     return -1;
                                                                                                                                                            Severity: Major
                                                                                                                                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                              Avoid too many return statements within this method.
                                                                                                                                                              Open

                                                                                                                                                                          return 30;
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                Avoid too many return statements within this method.
                                                                                                                                                                Open

                                                                                                                                                                            return jjStopAtPos(1, 29);
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                  Avoid too many return statements within this method.
                                                                                                                                                                  Open

                                                                                                                                                                              return jjStartNfaWithStates_2(1, 28, 30);
                                                                                                                                                                  Severity: Major
                                                                                                                                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                    Avoid too many return statements within this method.
                                                                                                                                                                    Open

                                                                                                                                                                             return -1;
                                                                                                                                                                    Severity: Major
                                                                                                                                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                      Avoid too many return statements within this method.
                                                                                                                                                                      Open

                                                                                                                                                                                  return jjStopAtPos(1, 31);
                                                                                                                                                                      Severity: Major
                                                                                                                                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                        Avoid too many return statements within this method.
                                                                                                                                                                        Open

                                                                                                                                                                                    return jjStopAtPos(1, 31);
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                          Avoid too many return statements within this method.
                                                                                                                                                                          Open

                                                                                                                                                                                      return jjStartNfaWithStates_2(1, 34, 30);
                                                                                                                                                                          Severity: Major
                                                                                                                                                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                            Avoid too many return statements within this method.
                                                                                                                                                                            Open

                                                                                                                                                                                        return 30;
                                                                                                                                                                            Severity: Major
                                                                                                                                                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                              Avoid too many return statements within this method.
                                                                                                                                                                              Open

                                                                                                                                                                                          return 30;
                                                                                                                                                                              Severity: Major
                                                                                                                                                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                Avoid too many return statements within this method.
                                                                                                                                                                                Open

                                                                                                                                                                                            return 30;
                                                                                                                                                                                Severity: Major
                                                                                                                                                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                  Avoid too many return statements within this method.
                                                                                                                                                                                  Open

                                                                                                                                                                                              return 30;
                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                    Avoid too many return statements within this method.
                                                                                                                                                                                    Open

                                                                                                                                                                                                return jjStartNfaWithStates_1(1, 30, 30);
                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                      Avoid too many return statements within this method.
                                                                                                                                                                                      Open

                                                                                                                                                                                               return jjMoveStringLiteralDfa1_2(0x200000000L);
                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                        Avoid too many return statements within this method.
                                                                                                                                                                                        Open

                                                                                                                                                                                                    return jjStartNfaWithStates_1(1, 32, 30);
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                          Avoid too many return statements within this method.
                                                                                                                                                                                          Open

                                                                                                                                                                                                      return 30;
                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                            Avoid too many return statements within this method.
                                                                                                                                                                                            Open

                                                                                                                                                                                                        return 30;
                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                              Avoid too many return statements within this method.
                                                                                                                                                                                              Open

                                                                                                                                                                                                       return -1;
                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                Avoid too many return statements within this method.
                                                                                                                                                                                                Open

                                                                                                                                                                                                            return jjStopAtPos(1, 33);
                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                  Avoid too many return statements within this method.
                                                                                                                                                                                                  Open

                                                                                                                                                                                                     return jjStartNfa_2(1, active0);
                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                    Avoid too many return statements within this method.
                                                                                                                                                                                                    Open

                                                                                                                                                                                                             return -1;
                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                      Avoid too many return statements within this method.
                                                                                                                                                                                                      Open

                                                                                                                                                                                                                  return jjStartNfaWithStates_1(2, 38, 30);
                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                        Avoid too many return statements within this method.
                                                                                                                                                                                                        Open

                                                                                                                                                                                                                    return jjStopAtPos(1, 55);
                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                        Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                          Avoid too many return statements within this method.
                                                                                                                                                                                                          Open

                                                                                                                                                                                                             return jjStartNfa_1(0, active0);
                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                          Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                            Avoid too many return statements within this method.
                                                                                                                                                                                                            Open

                                                                                                                                                                                                               return jjStartNfa_1(3, active0);
                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                            Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                              Avoid too many return statements within this method.
                                                                                                                                                                                                              Open

                                                                                                                                                                                                                          return jjStartNfaWithStates_1(1, 42, 30);
                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                              Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                                Avoid too many return statements within this method.
                                                                                                                                                                                                                Open

                                                                                                                                                                                                                   return jjStartNfa_1(2, active0);
                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                                  Avoid too many return statements within this method.
                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                              return jjStopAtPos(1, 41);
                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                  Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                                    Avoid too many return statements within this method.
                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                return jjStartNfaWithStates_1(2, 50, 30);
                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                    Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                                      Avoid too many return statements within this method.
                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                  return jjStartNfaWithStates_1(1, 26, 30);
                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                      Found in zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java - About 30 mins to fix

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveNfa_1(int startState, int curPos)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           int startsAt = 0;
                                                                                                                                                                                                                           jjnewStateCnt = 30;
                                                                                                                                                                                                                           int i = 1;
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 716..1053

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 2155.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveNfa_2(int startState, int curPos)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           int startsAt = 0;
                                                                                                                                                                                                                           jjnewStateCnt = 30;
                                                                                                                                                                                                                           int i = 1;
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1491..1828

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 2155.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa1_1(long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                           catch(java.io.IOException e) {
                                                                                                                                                                                                                              jjStopStringLiteralDfa_1(0, active0);
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 434..505

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 520.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa1_2(long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                           catch(java.io.IOException e) {
                                                                                                                                                                                                                              jjStopStringLiteralDfa_2(0, active0);
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1227..1298

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 520.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private final int jjStopStringLiteralDfa_2(int pos, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           switch (pos)
                                                                                                                                                                                                                           {
                                                                                                                                                                                                                              case 0:
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1054..1142

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 513.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private final int jjStopStringLiteralDfa_1(int pos, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           switch (pos)
                                                                                                                                                                                                                           {
                                                                                                                                                                                                                              case 0:
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 261..349

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 513.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa0_1()
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           switch(curChar)
                                                                                                                                                                                                                           {
                                                                                                                                                                                                                              case 33:
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 354..433

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 425.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa0_2()
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           switch(curChar)
                                                                                                                                                                                                                           {
                                                                                                                                                                                                                              case 33:
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1147..1226

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 425.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa2_2(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_2(0, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1299..1336

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 237.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa2_1(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_1(0, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 506..543

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 237.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa3_1(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_1(1, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 544..571

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 159.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa3_2(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_2(1, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1337..1364

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 159.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa4_1(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_1(2, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 572..597

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 147.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa4_2(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_2(2, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1365..1390

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 147.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                             case 1:
                                                                                                                                                                                                                               try { input_stream.backup(0);
                                                                                                                                                                                                                                  while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
                                                                                                                                                                                                                                     curChar = input_stream.BeginToken();
                                                                                                                                                                                                                               }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 2025..2038

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 112.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                             case 2:
                                                                                                                                                                                                                               try { input_stream.backup(0);
                                                                                                                                                                                                                                  while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
                                                                                                                                                                                                                                     curChar = input_stream.BeginToken();
                                                                                                                                                                                                                               }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 2011..2024

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 112.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa9_2(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_2(7, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1463..1482

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 105.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa9_1(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_1(7, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 670..689

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 105.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa6_1(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_1(4, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 598..615
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 616..633
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 634..651
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 652..669
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1391..1408
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1427..1444
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1445..1462

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 87.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa6_2(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_2(4, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 598..615
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 634..651
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 652..669
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1391..1408
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1409..1426
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1427..1444
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1445..1462

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 87.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa5_2(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_2(3, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 616..633
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 634..651
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 652..669
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1391..1408
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1409..1426
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1427..1444
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1445..1462

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 87.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa7_1(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_1(5, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 598..615
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 616..633
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 634..651
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 652..669
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1391..1408
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1409..1426
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1445..1462

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 87.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa8_1(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_1(6, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 598..615
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 616..633
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 634..651
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 652..669
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1391..1408
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1409..1426
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1427..1444

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 87.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa5_1(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_1(3, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 598..615
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 616..633
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 634..651
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 652..669
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1409..1426
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1427..1444
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1445..1462

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 87.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa7_2(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_2(5, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 598..615
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 616..633
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 652..669
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1391..1408
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1409..1426
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1427..1444
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1445..1462

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 87.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjMoveStringLiteralDfa8_2(long old0, long active0)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           if (((active0 &= old0)) == 0L)
                                                                                                                                                                                                                              return jjStartNfa_2(6, old0);
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 598..615
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 616..633
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 634..651
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1391..1408
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1409..1426
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1427..1444
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1445..1462

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 87.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjStartNfaWithStates_1(int pos, int kind, int state)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           jjmatchedKind = kind;
                                                                                                                                                                                                                           jjmatchedPos = pos;
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 690..697

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 60.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        private int jjStartNfaWithStates_2(int pos, int kind, int state)
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                           jjmatchedKind = kind;
                                                                                                                                                                                                                           jjmatchedPos = pos;
                                                                                                                                                                                                                           try { curChar = input_stream.readChar(); }
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 1483..1490

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 60.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                              case 3 :
                                                                                                                                                                                                                                image.append(jjstrLiteralImages[3]);
                                                                                                                                                                                                                                lengthOfMatch = jjstrLiteralImages[3].length();
                                                                                                                                                                                                                                                               deque.push(DEFAULT);
                                                                                                                                                                                                                                 break;
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 2086..2090
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 2096..2100

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 40.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                              case 2 :
                                                                                                                                                                                                                                image.append(jjstrLiteralImages[2]);
                                                                                                                                                                                                                                lengthOfMatch = jjstrLiteralImages[2].length();
                                                                                                                                                                                                                                                              deque.push(DEFAULT);
                                                                                                                                                                                                                                 break;
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 2091..2095
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 2096..2100

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 40.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                              case 8 :
                                                                                                                                                                                                                                image.append(jjstrLiteralImages[8]);
                                                                                                                                                                                                                                lengthOfMatch = jjstrLiteralImages[8].length();
                                                                                                                                                                                                                                                         deque.push(curLexState);
                                                                                                                                                                                                                                 break;
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 2086..2090
                                                                                                                                                                                                                        zel/src/main/java/org/zkoss/zel/impl/parser/ELParserTokenManager.java on lines 2091..2095

                                                                                                                                                                                                                        Duplicated Code

                                                                                                                                                                                                                        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                        Tuning

                                                                                                                                                                                                                        This issue has a mass of 40.

                                                                                                                                                                                                                        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                        Refactorings

                                                                                                                                                                                                                        Further Reading

                                                                                                                                                                                                                        There are no issues that match your filters.

                                                                                                                                                                                                                        Category
                                                                                                                                                                                                                        Status