The flag indicating whether to handle an error with a fatal error page factory.

@return the new parameter value if set, else the old parameter value if set, or false if neither set.
432846
public static boolean getHandleErrorWithFatalErrorPageFactory() {
		Boolean parameterValue = get().getBoolean(HANDLE_ERROR_WITH_FATAL_PAGE_FACTORY, null);
		if (parameterValue != null) {
			return parameterValue;
		}

		// fall-back to the old parameter value if the new value is not set.
		return get().getBoolean(HANDLE_ERROR_WITH_FATAL_PAGE_FACTORY_DEPRECATED, false);
	}
39386
@Override
    public int checkAbleToSend()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "checkAbleToSend", this);

        int result = DestinationHandler.OUTPUT_HANDLER_NOT_FOUND;

        // If both destination and queuepoint are sendAllowed then we can put the message
        // If we are a linkHandler we have no queue point so only check the destination def
        // on the other hand if this is an MQLink then we will check sendAllowed on
        // the local itemstream.
        boolean isSendAllowedOnLocalization = true;
        if (_baseDestinationHandler.isMQLink() || !_baseDestinationHandler.isLink())
            isSendAllowedOnLocalization = _pToPLocalMsgsItemStream.isSendAllowed();

        // Check if the queue point is send allowed (which can be set at the individual
        // message point level)
        if (!isSendAllowedOnLocalization)
            result = DestinationHandler.OUTPUT_HANDLER_SEND_ALLOWED_FALSE;
        else if (_pToPLocalMsgsItemStream != null)
        {
            if (!_pToPLocalMsgsItemStream.isQFull())
                result = DestinationHandler.OUTPUT_HANDLER_FOUND;
            else
                result = DestinationHandler.OUTPUT_HANDLER_ALL_HIGH_LIMIT;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "checkAbleToSend", Integer.valueOf(result));
        return result;
    }
282494
private Configuration getErrorPageConfiguration() {
		return new AbstractConfiguration() {

			@Override
			public void configure(WebAppContext context) throws Exception {
				ErrorHandler errorHandler = context.getErrorHandler();
				context.setErrorHandler(new JettyEmbeddedErrorHandler(errorHandler));
				addJettyErrorPages(errorHandler, getErrorPages());
			}

		};
	}
1034376
public CompiledPlan plan() throws PlanningErrorException {
        // reset any error message
        m_recentErrorMsg = null;

        // what's going to happen next:
        //  If a parameterized statement exists, try to make a plan with it
        //  On success return the plan.
        //  On failure, try the plan again without parameterization

        if (m_paramzInfo != null) {
            try {
                // compile the plan with new parameters
                CompiledPlan plan = compileFromXML(m_paramzInfo.getParameterizedXmlSQL(),
                                                   m_paramzInfo.getParamLiteralValues());
                if (plan != null) {
                    if (plan.extractParamValues(m_paramzInfo)) {
                        return plan;
                    }
                }
                else if (DEBUGGING_STATIC_MODE_TO_RETRY_ON_ERROR) {
                    compileFromXML(m_paramzInfo.getParameterizedXmlSQL(),
                                   m_paramzInfo.getParamLiteralValues());
                }
                // fall through to try replan without parameterization.
            }
            catch (Exception | StackOverflowError e) {
                // ignore any errors planning with parameters
                // fall through to re-planning without them
                m_hasExceptionWhenParameterized = true;

                // note, expect real planning errors ignored here to be thrown again below
                m_recentErrorMsg = null;
                m_partitioning.resetAnalysisState();
            }
        }

        // if parameterization isn't requested or if it failed, plan here
        CompiledPlan plan = compileFromXML(m_xmlSQL, null);
        if (plan == null) {
            if (DEBUGGING_STATIC_MODE_TO_RETRY_ON_ERROR) {
                plan = compileFromXML(m_xmlSQL, null);
            }
            throw new PlanningErrorException(m_recentErrorMsg);
        }

        return plan;
    }
6553
public boolean handleError(DOMError error) {
        boolean fail = true;
        String severity = null;
        if (error.getSeverity() == DOMError.SEVERITY_WARNING) {
            fail = false;
            severity = "[Warning]";
        } else if (error.getSeverity() == DOMError.SEVERITY_ERROR) {
            severity = "[Error]";
        } else if (error.getSeverity() == DOMError.SEVERITY_FATAL_ERROR) {
            severity = "[Fatal Error]";
        }
        
        System.err.println(severity + ": " + error.getMessage() + "\t");
        System.err.println("Type : " + error.getType() + "\t" + "Related Data: "
                + error.getRelatedData() + "\t" + "Related Exception: "
                + error.getRelatedException() );
        
        return fail;
    }
567004
public java.lang.String getNewValue() {
    java.lang.Object ref = newValue_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      newValue_ = s;
      return s;
    }
  }
361084
public com.google.rpc.StatusOrBuilder getErrorOrBuilder() {
    if (resultCase_ == 4) {
       return (com.google.rpc.Status) result_;
    }
    return com.google.rpc.Status.getDefaultInstance();
  }
1074501
public boolean booleanValue()
    {
        final String value = getInternal(null, false);
        if (value == null) {
            return false;
        }
        return toBoolean(value);
    }
499370
public int runAndHandleErrors(String... args) {
		String[] argsWithoutDebugFlags = removeDebugFlags(args);
		boolean debug = argsWithoutDebugFlags.length != args.length;
		if (debug) {
			System.setProperty("debug", "true");
		}
		try {
			ExitStatus result = run(argsWithoutDebugFlags);
			// The caller will hang up if it gets a non-zero status
			if (result != null && result.isHangup()) {
				return (result.getCode() > 0) ? result.getCode() : 0;
			}
			return 0;
		}
		catch (NoArgumentsException ex) {
			showUsage();
			return 1;
		}
		catch (Exception ex) {
			return handleError(debug, ex);
		}
	}
362241
public static ExceptionCallback failOnError() {
        return new ExceptionCallback() {
            @Override
            public void exception(FailedEventInvocation invocation) {
                throw new AbortionException(invocation.getException());
            }
        };
    }
1082533
public static boolean mayThrowException(Node n) {
    switch (n.getToken()) {
      case CALL:
      case TAGGED_TEMPLATELIT:
      case GETPROP:
      case GETELEM:
      case THROW:
      case NEW:
      case ASSIGN:
      case INC:
      case DEC:
      case INSTANCEOF:
      case IN:
      case YIELD:
      case AWAIT:
        return true;
      case FUNCTION:
        return false;
      default:
        break;
    }
    for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {
      if (!ControlFlowGraph.isEnteringNewCfgNode(c) && mayThrowException(c)) {
        return true;
      }
    }
    return false;
  }
1319426
@ExceptionHandler(MethodArgumentNotValidException.class)
  @ResponseStatus(HttpStatus.BAD_REQUEST)
  @ResponseBody
  public ValidationResultInterface processValidationError(
      final MethodArgumentNotValidException pexception) {
    final BindingResult result = pexception.getBindingResult();
    final List<FieldError> fieldErrors = result.getFieldErrors();

    return processFieldErrors(fieldErrors);
  }
231724
public static boolean getBoolean(@NotNull ServletRequest request, @NotNull String param, boolean defaultValue) {
    String value = request.getParameter(param);
    return BooleanUtils.toBoolean(value);
  }
287218
public ErrorPageType<WebAppDescriptor> getOrCreateErrorPage()
   {
      List<Node> nodeList = model.get("error-page");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ErrorPageTypeImpl<WebAppDescriptor>(this, "error-page", model, nodeList.get(0));
      }
      return createErrorPage();
   }
5227
public int doEndTag()
            throws JspException {

        if(hasErrors())
            reportErrors();
        else {
            AbstractCallMethod cm = (AbstractCallMethod)getParent();
            cm.addParameter(_type, _isNull ? null : _value);
        }

        localRelease();
        return EVAL_PAGE;
    }
562397
function _onError(errorMessage, url, lineNumber, columnNumber, exception) {
  var onErrorReturn;

  // Execute the original window.onerror handler, if any
  if (_oldOnError && typeof _oldOnError === 'function') {
    onErrorReturn = _oldOnError.apply(this, arguments);
  }

  Canadarm.fatal(errorMessage, exception, {
    url: url,
    lineNumber: lineNumber,
    columnNumber: columnNumber
  });

  return onErrorReturn;
}
939856
public void handleError(final Throwable error) throws IOException {

		LOG.debug("Start handleError...");

		// Should the session be removed upon error?
		boolean terminate = ConfigurationProperties.getTerminateSessionOnError();
		// If we are unfriendly, terminate the session
		if (terminate) {
			invalidateSession();
		}

		// Are we in developer friendly error mode?
		boolean friendly = ConfigurationProperties.getDeveloperErrorHandling();

		FatalErrorPageFactory factory = Factory.newInstance(FatalErrorPageFactory.class);
		WComponent errorPage = factory.createErrorPage(friendly, error);

		String html = renderErrorPageToHTML(errorPage);

		// Setup the response
		Response response = getResponse();
		response.setContentType(WebUtilities.CONTENT_TYPE_HTML);

		// Make sure not cached
		getResponse().setHeader("Cache-Control", CacheType.NO_CACHE.getSettings());
		getResponse().setHeader("Pragma", "no-cache");
		getResponse().setHeader("Expires", "-1");

		getPrintWriter().println(html);

		LOG.debug("End handleError");
	}