pagecontextimpl.java

业界著名的tomcat服务器的最新6.0的源代码。

		return context.getAttribute(name);
	}

	public Enumeration<String> getAttributeNamesInScope(final int scope) {
		if (SecurityUtil.isPackageProtectionEnabled()) {
			return (Enumeration) AccessController
					.doPrivileged(new PrivilegedAction() {
						public Object run() {
							return doGetAttributeNamesInScope(scope);
						}
					});
		} else {
			return doGetAttributeNamesInScope(scope);
		}
	}

	private Enumeration doGetAttributeNamesInScope(int scope) {
		switch (scope) {
		case PAGE_SCOPE:
			return new Enumerator(attributes.keySet().iterator());

		case REQUEST_SCOPE:
			return request.getAttributeNames();

		case SESSION_SCOPE:
			if (session == null) {
				throw new IllegalStateException(Localizer
						.getMessage("jsp.error.page.noSession"));
			}
			return session.getAttributeNames();

		case APPLICATION_SCOPE:
			return context.getAttributeNames();

		default:
			throw new IllegalArgumentException("Invalid scope");
		}
	}

	public void removeAttribute(final String name) {

		if (name == null) {
			throw new NullPointerException(Localizer
					.getMessage("jsp.error.attribute.null_name"));
		}

		if (SecurityUtil.isPackageProtectionEnabled()) {
			AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					doRemoveAttribute(name);
					return null;
				}
			});
		} else {
			doRemoveAttribute(name);
		}
	}

	private void doRemoveAttribute(String name) {
		try {
			removeAttribute(name, PAGE_SCOPE);
			removeAttribute(name, REQUEST_SCOPE);
			if (session != null) {
				removeAttribute(name, SESSION_SCOPE);
			}
			removeAttribute(name, APPLICATION_SCOPE);
		} catch (Exception ex) {
			// we remove as much as we can, and
			// simply ignore possible exceptions
		}
	}

	public JspWriter getOut() {
		return out;
	}

	public HttpSession getSession() {
		return session;
	}

	public Servlet getServlet() {
		return servlet;
	}

	public ServletConfig getServletConfig() {
		return config;
	}

	public ServletContext getServletContext() {
		return config.getServletContext();
	}

	public ServletRequest getRequest() {
		return request;
	}

	public ServletResponse getResponse() {
		return response;
	}

	/**
	 * Returns the exception associated with this page context, if any. <p/>
	 * Added wrapping for Throwables to avoid ClassCastException: see Bugzilla
	 * 31171 for details.
	 * 
	 * @return The Exception associated with this page context, if any.
	 */
	public Exception getException() {
		Throwable t = JspRuntimeLibrary.getThrowable(request);

		// Only wrap if needed
		if ((t != null) && (!(t instanceof Exception))) {
			t = new JspException(t);
		}

		return (Exception) t;
	}

	public Object getPage() {
		return servlet;
	}

	private final String getAbsolutePathRelativeToContext(String relativeUrlPath) {
		String path = relativeUrlPath;

		if (!path.startsWith("/")) {
			String uri = (String) request
					.getAttribute("javax.servlet.include.servlet_path");
			if (uri == null)
				uri = ((HttpServletRequest) request).getServletPath();
			String baseURI = uri.substring(0, uri.lastIndexOf('/'));
			path = baseURI + '/' + path;
		}

		return path;
	}

	public void include(String relativeUrlPath) throws ServletException,
			IOException {
		JspRuntimeLibrary
				.include(request, response, relativeUrlPath, out, true);
	}

	public void include(final String relativeUrlPath, final boolean flush)
			throws ServletException, IOException {
		if (SecurityUtil.isPackageProtectionEnabled()) {
			try {
				AccessController.doPrivileged(new PrivilegedExceptionAction() {
					public Object run() throws Exception {
						doInclude(relativeUrlPath, flush);
						return null;
					}
				});
			} catch (PrivilegedActionException e) {
				Exception ex = e.getException();
				if (ex instanceof IOException) {
					throw (IOException) ex;
				} else {
					throw (ServletException) ex;
				}
			}
		} else {
			doInclude(relativeUrlPath, flush);
		}
	}

	private void doInclude(String relativeUrlPath, boolean flush)
			throws ServletException, IOException {
		JspRuntimeLibrary.include(request, response, relativeUrlPath, out,
				flush);
	}

	public VariableResolver getVariableResolver() {
		return new VariableResolverImpl(this.getELContext());
	}

	public void forward(final String relativeUrlPath) throws ServletException,
			IOException {
		if (SecurityUtil.isPackageProtectionEnabled()) {
			try {
				AccessController.doPrivileged(new PrivilegedExceptionAction() {
					public Object run() throws Exception {
						doForward(relativeUrlPath);
						return null;
					}
				});
			} catch (PrivilegedActionException e) {
				Exception ex = e.getException();
				if (ex instanceof IOException) {
					throw (IOException) ex;
				} else {
					throw (ServletException) ex;
				}
			}
		} else {
			doForward(relativeUrlPath);
		}
	}

	private void doForward(String relativeUrlPath) throws ServletException,
			IOException {

		// JSP.4.5 If the buffer was flushed, throw IllegalStateException
		try {
			out.clear();
		} catch (IOException ex) {
			IllegalStateException ise = new IllegalStateException(Localizer
					.getMessage("jsp.error.attempt_to_clear_flushed_buffer"));
			ise.initCause(ex);
			throw ise;
		}

		// Make sure that the response object is not the wrapper for include
		while (response instanceof ServletResponseWrapperInclude) {
			response = ((ServletResponseWrapperInclude) response).getResponse();
		}

		final String path = getAbsolutePathRelativeToContext(relativeUrlPath);
		String includeUri = (String) request
				.getAttribute(Constants.INC_SERVLET_PATH);

		if (includeUri != null)
			request.removeAttribute(Constants.INC_SERVLET_PATH);
		try {
			context.getRequestDispatcher(path).forward(request, response);
		} finally {
			if (includeUri != null)
				request.setAttribute(Constants.INC_SERVLET_PATH, includeUri);
		}
	}

	public BodyContent pushBody() {
		return (BodyContent) pushBody(null);
	}

	public JspWriter pushBody(Writer writer) {
		depth++;
		if (depth >= outs.length) {
			BodyContentImpl[] newOuts = new BodyContentImpl[depth + 1];
			for (int i = 0; i < outs.length; i++) {
				newOuts[i] = outs[i];
			}
			newOuts[depth] = new BodyContentImpl(out);
			outs = newOuts;
		}

		outs[depth].setWriter(writer);
		out = outs[depth];

		// Update the value of the "out" attribute in the page scope
		// attribute namespace of this PageContext
		setAttribute(OUT, out);

		return outs[depth];
	}

	public JspWriter popBody() {
		depth--;
		if (depth >= 0) {
			out = outs[depth];
		} else {
			out = baseOut;
		}

		// Update the value of the "out" attribute in the page scope
		// attribute namespace of this PageContext
		setAttribute(OUT, out);

		return out;
	}

	/**
	 * Provides programmatic access to the ExpressionEvaluator. The JSP
	 * Container must return a valid instance of an ExpressionEvaluator that can
	 * parse EL expressions.
	 */
	public ExpressionEvaluator getExpressionEvaluator() {
		return new ExpressionEvaluatorImpl(this.applicationContext.getExpressionFactory());
	}

	public void handlePageException(Exception ex) throws IOException,
			ServletException {
		// Should never be called since handleException() called with a
		// Throwable in the generated servlet.
		handlePageException((Throwable) ex);
	}

	public void handlePageException(final Throwable t) throws IOException,
			ServletException {
		if (t == null)
			throw new NullPointerException("null Throwable");

		if (SecurityUtil.isPackageProtectionEnabled()) {
			try {
				AccessController.doPrivileged(new PrivilegedExceptionAction() {
					public Object run() throws Exception {
						doHandlePageException(t);
						return null;
					}
				});
			} catch (PrivilegedActionException e) {
				Exception ex = e.getException();
				if (ex instanceof IOException) {
					throw (IOException) ex;
				} else {
					throw (ServletException) ex;
				}
			}
		} else {
			doHandlePageException(t);
		}

	}

	private void doHandlePageException(Throwable t) throws IOException,
			ServletException {

		if (errorPageURL != null && !errorPageURL.equals("")) {

			/*
			 * Set request attributes. Do not set the
			 * javax.servlet.error.exception attribute here (instead, set in the
			 * generated servlet code for the error page) in order to prevent
			 * the ErrorReportValve, which is invoked as part of forwarding the
			 * request to the error page, from throwing it if the response has
			 * not been committed (the response will have been committed if the
			 * error page is a JSP page).
			 */
			request.setAttribute("javax.servlet.jsp.jspException", t);
			request.setAttribute("javax.servlet.error.status_code",
					new Integer(HttpServletResponse.SC_INTERNAL_SERVER_ERROR));
			request.setAttribute("javax.servlet.error.request_uri",
					((HttpServletRequest) request).getRequestURI());
			request.setAttribute("javax.servlet.error.servlet_name", config
					.getServletName());
			try {
				forward(errorPageURL);
			} catch (IllegalStateException ise) {
				include(errorPageURL);
			}

			// The error page could be inside an include.

			Object newException = request
					.getAttribute("javax.servlet.error.exception");

			// t==null means the attribute was not set.
			if ((newException != null) && (newException == t)) {
				request.removeAttribute("javax.servlet.error.exception");
			}

			// now clear the error code - to prevent double handling.
			request.removeAttribute("javax.servlet.error.status_code");
			request.removeAttribute("javax.servlet.error.request_uri");
			request.removeAttribute("javax.servlet.error.status_code");
			request.removeAttribute("javax.servlet.jsp.jspException");

		} else {
			// Otherwise throw the exception wrapped inside a ServletException.
			// Set the exception as the root cause in the ServletException
			// to get a stack trace for the real problem
			if (t instanceof IOException)
				throw (IOException) t;
			if (t instanceof ServletException)
				throw (ServletException) t;
			if (t instanceof RuntimeException)
				throw (RuntimeException) t;

			Throwable rootCause = null;
			if (t instanceof JspException) {
				rootCause = ((JspException) t).getRootCause();
			} else if (t instanceof ELException) {
				rootCause = ((ELException) t).getRootCause();
			}

			if (rootCause != null) {
				throw new ServletException(t.getClass().getName() + ": "
						+ t.getMessage(), rootCause);
			}

			throw new ServletException(t);
		}
	}

	private static String XmlEscape(String s) {
		if (s == null)
			return null;
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (c == '<') {
				sb.append("&lt;");
			} else if (c == '>') {
				sb.append("&gt;");
			} else if (c == '\'') {
				sb.append("&#039;"); // &apos;
			} else if (c == '&') {
				sb.append("&amp;");
			} else if (c == '"') {
				sb.append("&#034;"); // &quot;
			} else {
				sb.append(c);
			}
		}
		return sb.toString();
	}

	/**
	 * Proprietary method to evaluate EL expressions. XXX - This method should
	 * go away once the EL interpreter moves out of JSTL and into its own
	 * project. For now, this is necessary because the standard machinery is too
	 * slow.
	 * 
	 * @param expression
	 *            The expression to be evaluated
	 * @param expectedType
	 *            The expected resulting type
	 * @param pageContext
	 *            The page context
	 * @param functionMap
	 *            Maps prefix and name to Method
	 * @return The result of the evaluation
	 */
	public static Object proprietaryEvaluate(final String expression,
			final Class expectedType, final PageContext pageContext,
			final ProtectedFunctionMapper functionMap, final boolean escape)
			throws ELException {
		Object retValue;
        final ExpressionFactory exprFactory = JspFactory.getDefaultFactory().getJspApplicationContext(pageContext.getServletContext()).getExpressionFactory();
		if (SecurityUtil.isPackageProtectionEnabled()) {
			try {
				retValue = AccessController
						.doPrivileged(new PrivilegedExceptionAction() {

							public Object run() throws Exception {
                                ELContextImpl ctx = (ELContextImpl) pageContext.getELContext();
                                ctx.setFunctionMapper(new FunctionMapperImpl(functionMap));
								ValueExpression ve = exprFactory.createValueExpression(ctx, expression, expectedType);
                                return ve.getValue(ctx);
							}
						});
			} catch (PrivilegedActionException ex) {
				Exception realEx = ex.getException();
				if (realEx instanceof ELException) {
					throw (ELException) realEx;
				} else {
					throw new ELException(realEx);
				}
			}
		} else {
            ELContextImpl ctx = (ELContextImpl) pageContext.getELContext();
            ctx.setFunctionMapper(new FunctionMapperImpl(functionMap));
            ValueExpression ve = exprFactory.createValueExpression(ctx, expression, expectedType);
            retValue = ve.getValue(ctx);
		}
		if (escape && retValue != null) {
			retValue = XmlEscape(retValue.toString());
		}

		return retValue;
	}

	public ELContext getELContext() {
		if (this.elContext == null) {
			this.elContext = this.applicationContext.createELContext(this);
		}
		return this.elContext;
	}

}