Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   * 
   *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.apache.jasper.runtime;
 
 import static org.jboss.web.JasperMessages.MESSAGES;
 
 import java.io.Writer;
 
 
Implementation of the PageContext class from the JSP spec. Also doubles as a VariableResolver for the EL.

Author(s):
Anil K. Vijendran
Larry Cable
Hans Bergsten
Pierre Delisle
Mark Roth
Jan Luehe
Jacob Hookom
 
 public class PageContextImpl extends PageContext {
 
     private static JspFactory jspf = JspFactory.getDefaultFactory();
     
 	private BodyContentImpl[] outs;
 
 	private int depth;
 
 	// per-servlet state
 	private Servlet servlet;
 
 	private ServletConfig config;
 
 
 
 	private String errorPageURL;
 
 	// page-scope attributes
 	private transient HashMap<StringObjectattributes;
 
 	// per-request state
 	private transient ServletRequest request;
 
 	private transient ServletResponse response;
 
 	private transient HttpSession session;
	private transient ELContextImpl elContext;
	private boolean isIncluded;
	// initial output stream
	private transient JspWriter out;
	private transient JspWriterImpl baseOut;
	/*
	 * Constructor.
	 */
		this. = new BodyContentImpl[0];
		this. = new HashMap<StringObject>(16);
		this. = -1;
	}
	public void initialize(Servlet servletServletRequest request,
			ServletResponse responseString errorPageURL,
			boolean needsSessionint bufferSizeboolean autoFlush)
			throws IOException {
		_initialize(servletrequestresponseerrorPageURLneedsSession,
				bufferSizeautoFlush);
	}
	private void _initialize(Servlet servletServletRequest request,
			ServletResponse responseString errorPageURL,
			boolean needsSessionint bufferSizeboolean autoFlush)
			throws IOException {
		// initialize state
		this. = servlet;
		this. = servlet.getServletConfig();
		this. = errorPageURL;
		this. = request;
		this. = response;
		// initialize application context
		this. = JspApplicationContextImpl.getInstance();
		// Setup session (if required)
		if (request instanceof HttpServletRequest && needsSession)
			this. = ((HttpServletRequestrequest).getSession();
		if (needsSession &&  == null)
		// initialize the initial out ...
		 = -1;
        if (bufferSize == .) {
            bufferSize = .;
        }
		if (this. == null) {
			this. = new JspWriterImpl(responsebufferSizeautoFlush);
else {
			this..init(responsebufferSizeautoFlush);
		}
		this. = ;
		// register names/values as per spec
		if ( != null)
		setAttribute(servlet);
		 = request.getAttribute("javax.servlet.include.servlet_path") != null;
	}
	public void release() {
		try {
			if () {
				// push it into the including jspWriter
else {
				// Old code:
				// out.flush();
				// Do not flush the buffer even if we're not included (i.e.
				// we are the main page. The servlet will flush it and close
				// the stream.
			}
catch (IOException ex) {
            throw .errorFlushingData(ex);
finally {
		     = null;
		     = null;
		     = null;
		     = null;
		     = null;
		     = null;
		     = null;
		     = null;
		     = -1;
		    .recycle();
		     = null;
		    .clear();
        }
	}
	public Object getAttribute(final String name) {
		if (name == null) {
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			return AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					return doGetAttribute(name);
				}
			});
else {
			return doGetAttribute(name);
		}
	}
	private Object doGetAttribute(String name) {
		return .get(name);
	}
	public Object getAttribute(final String namefinal int scope) {
		if (name == null) {
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			return AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					return doGetAttribute(namescope);
				}
			});
else {
			return doGetAttribute(namescope);
		}
	}
	private Object doGetAttribute(String nameint scope) {
		switch (scope) {
			return .get(name);
			return .getAttribute(name);
			if ( == null) {
			}
			return .getAttribute(name);
			return .getAttribute(name);
		default:
		}
	}
	public void setAttribute(final String namefinal Object attribute) {
		if (name == null) {
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					doSetAttribute(nameattribute);
					return null;
				}
			});
else {
			doSetAttribute(nameattribute);
		}
	}
	private void doSetAttribute(String nameObject attribute) {
		if (attribute != null) {
			.put(nameattribute);
else {
		}
	}
	public void setAttribute(final String namefinal Object ofinal int scope) {
		if (name == null) {
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					doSetAttribute(nameoscope);
					return null;
				}
			});
else {
			doSetAttribute(nameoscope);
		}
	}
	private void doSetAttribute(String nameObject oint scope) {
		if (o != null) {
			switch (scope) {
				.put(nameo);
				break;
				break;
				if ( == null) {
				}
				break;
				break;
			default:
			}
else {
			removeAttribute(namescope);
		}
	}
	public void removeAttribute(final String namefinal int scope) {
		if (name == null) {
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					doRemoveAttribute(namescope);
					return null;
				}
			});
else {
			doRemoveAttribute(namescope);
		}
	}
	private void doRemoveAttribute(String nameint scope) {
		switch (scope) {
			break;
			break;
			if ( == null) {
			}
			break;
			break;
		default:
		}
	}
	public int getAttributesScope(final String name) {
		if (name == null) {
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			return ((Integer) AccessController
						public Object run() {
							return new Integer(doGetAttributeScope(name));
						}
					})).intValue();
else {
			return doGetAttributeScope(name);
		}
	}
	private int doGetAttributeScope(String name) {
		if (.get(name) != null)
			return ;
		if (.getAttribute(name) != null)
		if ( != null) {
            try {
                if (.getAttribute(name) != null)
                    return ;
            } catch(IllegalStateException ise) {
                // Session has been invalidated.
                // Ignore and fall through to application scope.
            }
		}
		if (.getAttribute(name) != null)
		return 0;
	}
	public Object findAttribute(final String name) {
		if (SecurityUtil.isPackageProtectionEnabled()) {
			return AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					if (name == null) {
					}
					return doFindAttribute(name);
				}
			});
else {
			if (name == null) {
			}
			return doFindAttribute(name);
		}
	}
	private Object doFindAttribute(String name) {
		Object o = .get(name);
		if (o != null)
			return o;
		o = .getAttribute(name);
		if (o != null)
			return o;
		if ( != null) {
            try {
                o = .getAttribute(name);
            } catch(IllegalStateException ise) {
                // Session has been invalidated.
                // Ignore and fall through to application scope.
            }
			if (o != null)
				return o;
		}
		return .getAttribute(name);
	}
	public Enumeration<StringgetAttributeNamesInScope(final int scope) {
		if (SecurityUtil.isPackageProtectionEnabled()) {
			return (Enumeration) AccessController
						public Object run() {
						}
					});
else {
		}
	}
	private Enumeration doGetAttributeNamesInScope(int scope) {
		switch (scope) {
			if ( == null) {
			}
		default:
		}
	}
	public void removeAttribute(final String name) {
		if (name == null) {
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					return null;
				}
			});
else {
		}
	}
	private void doRemoveAttribute(String name) {
        removeAttribute(name);
        removeAttribute(name);
        if != null ) {
            try {
                removeAttribute(name);
            } catch(IllegalStateException ise) {
                // Session has been invalidated.
                // Ignore and fall throw to application scope.
            }
        }
        removeAttribute(name);
	}
	public JspWriter getOut() {
		return ;
	}
	public HttpSession getSession() {
		return ;
	}
	public Servlet getServlet() {
		return ;
	}
		return ;
	}
	}
		return ;
	}
		return ;
	}

Returns the exception associated with this page context, if any.

Added wrapping for Throwables to avoid ClassCastException: see Bugzilla 31171 for details.

Returns:
The Exception associated with this page context, if any.
	public Exception getException() {
		Throwable t = JspRuntimeLibrary.getThrowable();
		// Only wrap if needed
		if ((t != null) && (!(t instanceof Exception))) {
			t = new JspException(t);
		}
		return (Exceptiont;
	}
	public Object getPage() {
		return ;
	}
	private final String getAbsolutePathRelativeToContext(String relativeUrlPath) {
		String path = relativeUrlPath;
		if (!path.startsWith("/")) {
			String uri = (String
					.getAttribute("javax.servlet.include.servlet_path");
			if (uri == null)
			String baseURI = uri.substring(0, uri.lastIndexOf('/'));
			path = baseURI + '/' + path;
		}
		return path;
	}
	public void include(String relativeUrlPaththrows ServletException,
		JspRuntimeLibrary
				.include(relativeUrlPathtrue);
	}
	public void include(final String relativeUrlPathfinal boolean flush)
		if (SecurityUtil.isPackageProtectionEnabled()) {
			try {
				AccessController.doPrivileged(new PrivilegedExceptionAction() {
					public Object run() throws Exception {
						doInclude(relativeUrlPathflush);
						return null;
					}
				});
catch (PrivilegedActionException e) {
				if (ex instanceof IOException) {
					throw (IOExceptionex;
else {
					throw (ServletExceptionex;
				}
			}
else {
			doInclude(relativeUrlPathflush);
		}
	}
	private void doInclude(String relativeUrlPathboolean flush)
		JspRuntimeLibrary.include(relativeUrlPath,
				flush);
	}
		return new VariableResolverImpl(this.getELContext());
	}
	public void forward(final String relativeUrlPaththrows ServletException,
		if (SecurityUtil.isPackageProtectionEnabled()) {
			try {
				AccessController.doPrivileged(new PrivilegedExceptionAction() {
					public Object run() throws Exception {
						doForward(relativeUrlPath);
						return null;
					}
				});
catch (PrivilegedActionException e) {
				if (ex instanceof IOException) {
					throw (IOExceptionex;
else {
					throw (ServletExceptionex;
				}
			}
else {
			doForward(relativeUrlPath);
		}
	}
	private void doForward(String relativeUrlPaththrows ServletException,
		// JSP.4.5 If the buffer was flushed, throw IllegalStateException
		try {
catch (IOException ex) {
		}
		// Make sure that the response object is not the wrapper for include
		while ( instanceof ServletResponseWrapperInclude) {
		}
		final String path = getAbsolutePathRelativeToContext(relativeUrlPath);
		String includeUri = (String
		if (includeUri != null)
		try {
finally {
			if (includeUri != null)
		}
	}
	public BodyContent pushBody() {
		return (BodyContentpushBody(null);
	}
	public JspWriter pushBody(Writer writer) {
		if ( >= .) {
			BodyContentImpl[] newOuts = new BodyContentImpl[ + 1];
			for (int i = 0; i < .i++) {
				newOuts[i] = [i];
			}
			newOuts[] = new BodyContentImpl();
			 = newOuts;
		}
		// Update the value of the "out" attribute in the page scope
		// attribute namespace of this PageContext
		return [];
	}
	public JspWriter popBody() {
		if ( >= 0) {
else {
		}
		// Update the value of the "out" attribute in the page scope
		// attribute namespace of this PageContext
		return ;
	}

Provides programmatic access to the ExpressionEvaluator. The JSP Container must return a valid instance of an ExpressionEvaluator that can parse EL expressions.
	}
	public void handlePageException(Exception exthrows IOException,
		// Should never be called since handleException() called with a
		// Throwable in the generated servlet.
	}
	public void handlePageException(final Throwable tthrows IOException,
		if (t == null)
		if (SecurityUtil.isPackageProtectionEnabled()) {
			try {
				AccessController.doPrivileged(new PrivilegedExceptionAction() {
					public Object run() throws Exception {
						return null;
					}
				});
catch (PrivilegedActionException e) {
				if (ex instanceof IOException) {
					throw (IOExceptionex;
else {
					throw (ServletExceptionex;
				}
			}
else {
		}
	}
	private void doHandlePageException(Throwable tthrows IOException,
		if ( != null && !.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).
			 */
			.setAttribute("javax.servlet.jsp.jspException"t);
			.setAttribute("javax.servlet.error.status_code",
			.setAttribute("javax.servlet.error.request_uri",
			.setAttribute("javax.servlet.error.servlet_name"
			try {
catch (IllegalStateException ise) {
			}
			// The error page could be inside an include.
			Object newException = 
					.getAttribute("javax.servlet.error.exception");
			// t==null means the attribute was not set.
			if ((newException != null) && (newException == t)) {
				.removeAttribute("javax.servlet.error.exception");
			}
			// now clear the error code - to prevent double handling.
			.removeAttribute("javax.servlet.error.status_code");
			.removeAttribute("javax.servlet.error.request_uri");
			.removeAttribute("javax.servlet.error.status_code");
			.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 (IOExceptiont;
			if (t instanceof ServletException)
				throw (ServletExceptiont;
			if (t instanceof RuntimeException)
				throw (RuntimeExceptiont;
			Throwable rootCause = null;
			if (t instanceof JspException) {
				rootCause = ((JspExceptiont).getRootCause();
else if (t instanceof ELException) {
				rootCause = ((ELExceptiont).getRootCause();
			}
			if (rootCause != null) {
				throw new ServletException(t.getClass().getName() + ": "
t.getMessage(), rootCause);
			}
			throw new ServletException(t);
		}
	}

    
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.

Parameters:
expression The expression to be evaluated
expectedType The expected resulting type
pageContext The page context
functionMap Maps prefix and name to Method
Returns:
The result of the evaluation
	public static Object proprietaryEvaluate(final String expression,
			final Class expectedTypefinal PageContext pageContext,
			final ProtectedFunctionMapper functionMapfinal boolean escape)
			throws ELException {
		Object retValue;
        final ExpressionFactory exprFactory = .getJspApplicationContext(pageContext.getServletContext()).getExpressionFactory();
		if (SecurityUtil.isPackageProtectionEnabled()) {
			try {
				retValue = AccessController
							public Object run() throws Exception {
                                ELContextImpl ctx = (ELContextImplpageContext.getELContext();
                                ctx.setFunctionMapper(new FunctionMapperImpl(functionMap));
								ValueExpression ve = exprFactory.createValueExpression(ctxexpressionexpectedType);
                                return ve.getValue(ctx);
							}
						});
catch (PrivilegedActionException ex) {
				Exception realEx = ex.getException();
				if (realEx instanceof ELException) {
					throw (ELExceptionrealEx;
else {
					throw new ELException(realEx);
				}
			}
else {
            ELContextImpl ctx = (ELContextImplpageContext.getELContext();
            ctx.setFunctionMapper(new FunctionMapperImpl(functionMap));
            ValueExpression ve = exprFactory.createValueExpression(ctxexpressionexpectedType);
            retValue = ve.getValue(ctx);
		}
		return retValue;
	}
	public ELContext getELContext() {
		if (this. == null) {
		}
		return this.;
	}
New to GrepCode? Check out our FAQ X