docs: private void handleUndeliverableMessage(
                                              DestinationHandler destinationHandler,
                                              LinkHandler linkHandler,
                                              SIMPMessage msg,
                                              int exceptionReason,
                                              String[] exceptionInserts,
                                              TransactionCommon tran) throws SIResourceException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(
                          tc,
                          "handleUndeliverableMessage",
                          new Object[] { destinationHandler, linkHandler, msg, new Integer(exceptionReason), exceptionInserts,
                                        tran });
  
          // Destination exception destination handler
          ExceptionDestinationHandlerImpl destExceptionDestination = null;
          // Link exception destination handler
          ExceptionDestinationHandlerImpl linkExceptionDestination = null;
  
          // Create handlers associated with the destination and link handlers
          if (destinationHandler == null)
          {
              if (linkHandler == null)
              {
                  // Where both handlers are null retain the behaviour that uses the default exception destination.
                  destExceptionDestination = new ExceptionDestinationHandlerImpl(null, _messageProcessor);
              }
              // if the linkHandler is non null, then we'll establish a linkExceptionDestination below
          }
          else
          {
              // destinationHandler is non null
              destExceptionDestination = new ExceptionDestinationHandlerImpl(destinationHandler);
          } // eof destinationHandler != null
  
          UndeliverableReturnCode rc = UndeliverableReturnCode.OK;
          // Pass the undeliverable message to the destination exception destination if it is not null
          if (destExceptionDestination != null)
          {
              rc =
                              destExceptionDestination.handleUndeliverableMessage(
                                                                                  msg,
                                                                                  tran,
                                                                                  exceptionReason,
                                                                                  exceptionInserts);
          }
  
          // If no destination exception destination was established or if we got a BLOCK return from the use
          // of the destination exception destination, then we drive the link exception destination
          if (destExceptionDestination == null || rc == UndeliverableReturnCode.BLOCK)
          {
              // Get the Link Exception Destination
              if (linkHandler != null)
              {
                  linkExceptionDestination = new ExceptionDestinationHandlerImpl(linkHandler);
  
                  rc =
                                  linkExceptionDestination.handleUndeliverableMessage(
                                                                                      msg,
                                                                                      tran,
                                                                                      exceptionReason,
                                                                                      exceptionInserts);
              }
          }
  
          // If the ExceptionDestinationHandlerImpl.handleUndeliverableMessage() call returned either a
          // "BLOCK" or an "ERROR" return then we throw an exception. BLOCK will be returned if the exception
          // destination is full or if a null or empty exception destination was configured.
          //
          // In the error case we generate an FFDC but in both cases we throw an exception to get the caller to
          // fail the attempt to store the message, forcing it to either return the error or retry at it's discretion.
          if (rc == UndeliverableReturnCode.BLOCK)
          {
              // Throw an exception
              SIResourceException e = new SIResourceException(
                              nls.getFormattedMessage(
                                                      "INTERNAL_MESSAGING_ERROR_CWSIP0005",
                                                      new Object[] {
                                                                    "com.ibm.ws.sib.processor.impl.PtoPInputHandler",
                                                                    "1:3103:1.323",
                                                                    rc },
                                                      null));
  
              SibTr.exception(tc, e);
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(tc, "handleUndeliverableMessage", e);
  
              throw e;
          }
          // An ERROR just isn't acceptable
          else if (rc == UndeliverableReturnCode.ERROR)
          {
              //We cannot put the message to the exception destination.  Throw an
              //exception and trace FFST.
              SIErrorException e = new SIErrorException(
                              nls.getFormattedMessage(
                                                      "INTERNAL_MESSAGING_ERROR_CWSIP0005",
                                                      new Object[] {
                                                                    "com.ibm.ws.sib.processor.impl.PtoPInputHandler",
                                                                    "1:3124:1.323",
                                                                    rc },
                                                      null));
  
              FFDCFilter.processException(
                                          e,
                                          "com.ibm.ws.sib.processor.impl.PtoPInputHandler.handleUndeliverableMessage",
                                          "1:3131:1.323",
                                          this);
  
              SibTr.exception(tc, e);
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(tc, "handleUndeliverableMessage", e);
  
              throw e;
          }
          // otherwise a DISCARD is equivalent to an OK so let it go
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "handleUndeliverableMessage");
  
          return;
  
      }