7156b-8643.patch

Dănuț Filimon, 06/26/2024 03:52 AM

     ** Module   : BlockManager.java
     ** Abstract : common "scaffolding" for executing Progress-compatible code blocks
     **
     ** Copyright (c) 2008-2023, Golden Code Development Corporation.
     ** Copyright (c) 2008-2024, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- --JPRM-- ----------------------------------Description-----------------------------------
     ** 001 GES 20080509   @38517 Created initial version. Implements the core
-...
     **     DDF 20240524          Revert re-throw change and avoid NPE when matching condition is null.
     ** 083 CA  20240609          Once a structured exception is re-thrown, mark it as explicit, so it can be
     **                           re-thrown via top-level blocks.
     ** 084 CA  20240625          Certain database-level ERROR conditions (like 132/buffer already exists with)
     **                           must be processed as if BLOCK-LEVEL ON ERROR UNDO, THROW is set (in other words,
     **                           it can get morphed into a strcutured exceptions).
     */
     /*
-...
+        *
         * @param   wa
         *          The {@link WorkArea} instance.
         * @param   forceBlockLevelUndoThrow
         *          Flag indicating that, when nothing else matches, a BLOCK-LEVEL UNDO, THROW exists by default.
+        *
         * @return  see above.
         */
        static boolean mustManageLegacyError(WorkArea wa, boolean forceBlockLevelUndoThrow)
+       {
           return wa.pm._thisProcedure() != null &&
                 (forceBlockLevelUndoThrow ||
                  (wa.tm.isRootNestingLevel() && AppServerManager.isRemote() && wa.pm.isRoutineLevelUndoThrow()) ||
                  (wa.tm.isTopLevelBlock() && wa.pm.isRoutineLevelUndoThrow())                                   ||
                  wa.pm.isBlockLevelUndoThrow());
+       }
        /**
         * Check if the top-level block is ROUTINE-LEVEL UNDO, THROW or the current program is
         * BLOCK-LEVEL UNDO, THROW.
+        *
         * @param   forceBlockLevelUndoThrow
         *          Flag indicating that, when nothing else matches, a BLOCK-LEVEL UNDO, THROW exists by default.
+        *
         * @return  see above.
         */
        static boolean mustManageLegacyError(boolean forceBlockLevelUndoThrow)
+       {
           return mustManageLegacyError(work.obtain(), forceBlockLevelUndoThrow);
+       }
        /**
         * Check if the top-level block is ROUTINE-LEVEL UNDO, THROW or the current program is
         * BLOCK-LEVEL UNDO, THROW.
+        *
         * @param   wa
         *          The {@link WorkArea} instance.
+        *
         * @return  see above.
         */
-...
              if (imple != null)
+             {
                 canThrow = canThrow || (imple.action == Action.THROW);
                 noThrowOnError = (imple.action != Action.THROW);
                 noThrowOnError = !lex.isExplicit() && (imple.action != Action.THROW);
+             }
+          }

     ** 092 CA  20240609          An ERROR condition must be triggered in the caller (outside of the top-level
     **                           block) is current file has ROUTINE-/BLOCK-LEVEL statetements and this condition
     **                           can't be morphed in a structured exception in the current stacktrace.
     ** 095 CA  20240625          Certain database-level ERROR conditions (like 132/buffer already exists with)
     **                           must be processed as if BLOCK-LEVEL ON ERROR UNDO, THROW is set (in other words,
     **                           it can get morphed into a strcutured exceptions).
     */
     /*
-...
           boolean silent = isSilentError();
           boolean manageLegacyError = da.mustThrowLegacyError();
           boolean mustManageError = !manageLegacyError && da.mustManageLegacyError();
           boolean forceExplicitException = false;
           if (!manageLegacyError && nums[0] == 132 && !ProcedureManager.getProcedureHelper().isBlockLevelUndoThrow())
+          {
              forceExplicitException = true;
              manageLegacyError = da.mustThrowLegacyError(true);
              mustManageError = !manageLegacyError && da.mustManageLegacyError(true);
+          }
           boolean throwError = false;
-...
                 if (last && throwError)
+                {
                    work.get().forceExplicit = forceExplicitException;
                    throw new DeferredLegacyErrorException();
+                }
-...
+       {
           return BlockManager.mustManageLegacyError();
+       }
        /**
         * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
+        *
         * @param   forceBlockLevelUndoThrow
         *          Flag indicating that, when nothing else matches, a BLOCK-LEVEL UNDO, THROW exists by default.
+        *
         * @return  see above.
         */
        public static boolean mustManageLegacyError(boolean forceBlockLevelUndoThrow)
+       {
           return BlockManager.mustManageLegacyError(forceBlockLevelUndoThrow);
+       }
        /**
         * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
-...
         */
        public static boolean mustThrowLegacyError()
+       {
           return mustThrowLegacyError(false);
+       }
        /**
         * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
+        *
         * @param   forceBlockLevelUndoThrow
         *          Flag indicating that, when nothing else matches, a BLOCK-LEVEL UNDO, THROW exists by default.
+        *
         * @return  see above.
         */
        public static boolean mustThrowLegacyError(boolean forceBlockLevelUndoThrow)
+       {
           return BlockManager.hasLegacyError(SysError.class, 0) ||
                  (BlockManager.mustManageLegacyError() &&
                  (BlockManager.mustManageLegacyError(forceBlockLevelUndoThrow) &&
                   (BlockManager.hasLegacyError(SysError.class, -1) ||
                    (TransactionManager.isRootNestingLevel() && AppServerManager.isRemote())));
+       }
-...
           object<? extends SysError> legacyError = wa.legacyError;
           wa.legacyError = null;
           return new LegacyErrorException(legacyError);
           LegacyErrorException lex = new LegacyErrorException(legacyError);
           lex.setExplicit(wa.forceExplicit);
           wa.forceExplicit = false;
           return lex;
+       }
        /**
-...
              return false;
+          }
           @Override
           public boolean mustManageLegacyError(boolean forceBlockLevelUndoThrow)
+          {
              return false;
+          }
           /**
            * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
+           *
-...
              return false;
+          }
           public boolean mustThrowLegacyError(boolean forceBlockLevelUndoThrow)
+          {
              return false;
+          }
           /**
            * Record the specified error message and number, to be later thrown as a
-...
           /**
            * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
+           *
            * @param   forceBlockLevelUndoThrow
            *          Flag indicating that, when nothing else matches, a BLOCK-LEVEL UNDO, THROW exists by default.
+           *
            * @return  see above.
            */
           @Override
           public boolean mustManageLegacyError(boolean forceBlockLevelUndoThrow)
+          {
              return ErrorManager.mustManageLegacyError(forceBlockLevelUndoThrow);
+          }
           /**
            * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
+           *
            * @return  see above.
            */
           @Override
-...
+          }
           /**
            * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
+           *
            * @param   forceBlockLevelUndoThrow
            *          Flag indicating that, when nothing else matches, a BLOCK-LEVEL UNDO, THROW exists by default.
+           *
            * @return  see above.
            */
           @Override
           public boolean mustThrowLegacyError(boolean forceBlockLevelUndoThrow)
+          {
              return ErrorManager.mustThrowLegacyError(forceBlockLevelUndoThrow);
+          }
           /**
            * Record the specified error message and number, to be later thrown as a
            * {@link LegacyErrorException}.
+           *
-...
+          {
              wa.silent = value;
+          }
           /**
            * Check if the top-level block is ROUTINE-LEVEL UNDO, THROW or the current program is
            * BLOCK-LEVEL UNDO, THROW.
+           *
            * @return  see above.
            */
           @Override
           public boolean mustManageLegacyError()
+          {
              return ErrorManager.mustManageLegacyError();
+          }
           /**
            * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
+           *
            * @param   forceBlockLevelUndoThrow
            *          Flag indicating that, when nothing else matches, a BLOCK-LEVEL UNDO, THROW exists by default.
+           *
            * @return  see above.
            */
           @Override
           public boolean mustManageLegacyError(boolean forceBlockLevelUndoThrow)
+          {
              return ErrorManager.mustManageLegacyError(forceBlockLevelUndoThrow);
+          }
           /**
            * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
+           *
            * @return  see above.
            */
           @Override
           public boolean mustThrowLegacyError()
+          {
              return ErrorManager.mustThrowLegacyError();
+          }
           /**
            * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
+           *
            * @param   forceBlockLevelUndoThrow
            *          Flag indicating that, when nothing else matches, a BLOCK-LEVEL UNDO, THROW exists by default.
+           *
            * @return  see above.
            */
           @Override
           public boolean mustThrowLegacyError(boolean forceBlockLevelUndoThrow)
+          {
              return ErrorManager.mustThrowLegacyError(forceBlockLevelUndoThrow);
+          }
+       }
        /**

     ** Module : RemoteErrorData.java
     ** Public : provides remote access to ErrorManager data
     **
     ** Copyright (c) 2005-2023, Golden Code Development Corporation.
     ** Copyright (c) 2005-2024, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- --JPRM-- ----------------------------------Description----------------------------------
     ** 001 NVS 20060303   @24884 Created initial version.
-...
     **                           be morphed into a legacy SysError exception, and not raise an ERROR condition.
     ** 013 GBB 20230313          New method writeLog added.
     ** 014 TT  20230614          Added the functionality for session:suppress-warnings-list.
     ** 016 CA  20240625          Certain database-level ERROR conditions (like 132/buffer already exists with)
     **                           must be processed as if BLOCK-LEVEL ON ERROR UNDO, THROW is set (in other words,
     **                           it can get morphed into a strcutured exceptions).
     */
     /*
-...
         * @return  see above.
         */
        public boolean mustManageLegacyError();
        /**
         * Check if the top-level block is ROUTINE-LEVEL UNDO, THROW or the current program is
         * BLOCK-LEVEL UNDO, THROW.
+        *
         * @param   forceBlockLevelUndoThrow
         *          Flag indicating that, when nothing else matches, a BLOCK-LEVEL UNDO, THROW exists by default.
+        *
         * @return  see above.
         */
        public boolean mustManageLegacyError(boolean forceBlockLevelUndoThrow);
        /**
         * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
-...
         * @return  see above.
         */
        public boolean mustThrowLegacyError();
        /**
         * Check if the current ERROR condition must be raised as a legacy {@link SysError}.
+        *
         * @param   forceBlockLevelUndoThrow
         *          Flag indicating that, when nothing else matches, a BLOCK-LEVEL UNDO, THROW exists by default.
+        *
         * @return  see above.
         */
        public boolean mustThrowLegacyError(boolean forceBlockLevelUndoThrow);
        /**
         * Record the specified error message and number, to be later thrown as a

Project

General

Profile

FWD » Core Development » Base Language

7156b-8643.patch