PageContextImpl() 
{
		this.outs = new BodyContentImpl[0];
		this.attributes = new HashMap< String, Object >(16);
		this.depth = -1;
}

 public Object findAttribute(String name) 
{
		if (SecurityUtil.isPackageProtectionEnabled()) {
			return AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					if (name == null) {
						throw new NullPointerException(Localizer
								.getMessage("jsp.error.attribute.null_name"));
					}
					return doFindAttribute(name);
				}
			});
		} else {
			if (name == null) {
				throw new NullPointerException(Localizer
						.getMessage("jsp.error.attribute.null_name"));
			}
			return doFindAttribute(name);
		}
}

 public  void forward(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);
		}
}

 public Object getAttribute(String name) 
{
		if (name == null) {
			throw new NullPointerException(Localizer
					.getMessage("jsp.error.attribute.null_name"));
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			return AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					return doGetAttribute(name);
				}
			});
		} else {
			return doGetAttribute(name);
		}
}

 public Object getAttribute(String name,
    int scope) 
{
		if (name == null) {
			throw new NullPointerException(Localizer
					.getMessage("jsp.error.attribute.null_name"));
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			return AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					return doGetAttribute(name, scope);
				}
			});
		} else {
			return doGetAttribute(name, scope);
		}
}

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

 public int getAttributesScope(String name) 
{
		if (name == null) {
			throw new NullPointerException(Localizer
					.getMessage("jsp.error.attribute.null_name"));
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			return ((Integer) AccessController
					.doPrivileged(new PrivilegedAction() {
						public Object run() {
							return new Integer(doGetAttributeScope(name));
						}
					})).intValue();
		} else {
			return doGetAttributeScope(name);
		}
}

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

 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;
}

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

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

 public ExpressionEvaluator getExpressionEvaluator() 
{
		return new ExpressionEvaluatorImpl(this.applicationContext.getExpressionFactory());
}

Provides programmatic access to the ExpressionEvaluator. The JSP Container must return a valid instance of an ExpressionEvaluator that can parse EL expressions.

 public JspWriter getOut() 
{
		return out;
}

 public Object getPage() 
{
		return servlet;
}

 public ServletRequest getRequest() 
{
		return request;
}

 public ServletResponse getResponse() 
{
		return response;
}

 public Servlet getServlet() 
{
		return servlet;
}

 public ServletConfig getServletConfig() 
{
		return config;
}

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

 public HttpSession getSession() 
{
		return session;
}

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

 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(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);
		}
}

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

 public  void include(String relativeUrlPath,
    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);
		}
}

 public  void initialize(Servlet servlet,
    ServletRequest request,
    ServletResponse response,
    String errorPageURL,
    boolean needsSession,
    int bufferSize,
    boolean autoFlush) throws IOException 
{
		_initialize(servlet, request, response, errorPageURL, needsSession,
				bufferSize, autoFlush);
}

 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;
}

 public static Object proprietaryEvaluate(String expression,
    Class expectedType,
    PageContext pageContext,
    ProtectedFunctionMapper functionMap,
    boolean escape) throws ELException 
{
		Object retValue;
        final ExpressionFactory exprFactory = jspf.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;
}

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.

 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  void release() 
{
		out = baseOut;
		try {
			if (isIncluded) {
				((JspWriterImpl) out).flushBuffer();
				// 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.
				((JspWriterImpl) out).flushBuffer();
			}
		} catch (IOException ex) {
            IllegalStateException ise = new IllegalStateException(Localizer.getMessage("jsp.error.flush"), ex);
            throw ise;
		} finally {
		    servlet = null;
		    config = null;
		    context = null;
		    applicationContext = null;
		    elContext = null;
		    errorPageURL = null;
		    request = null;
		    response = null;
		    depth = -1;
		    baseOut.recycle();
		    session = null;
		    attributes.clear();
        }
}

 public  void removeAttribute(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);
		}
}

 public  void removeAttribute(String name,
    int scope) 
{
		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, scope);
					return null;
				}
			});
		} else {
			doRemoveAttribute(name, scope);
		}
}

 public  void setAttribute(String name,
    Object attribute) 
{
		if (name == null) {
			throw new NullPointerException(Localizer
					.getMessage("jsp.error.attribute.null_name"));
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					doSetAttribute(name, attribute);
					return null;
				}
			});
		} else {
			doSetAttribute(name, attribute);
		}
}

 public  void setAttribute(String name,
    Object o,
    int scope) 
{
		if (name == null) {
			throw new NullPointerException(Localizer
					.getMessage("jsp.error.attribute.null_name"));
		}
		if (SecurityUtil.isPackageProtectionEnabled()) {
			AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					doSetAttribute(name, o, scope);
					return null;
				}
			});
		} else {
			doSetAttribute(name, o, scope);
		}
}