Object attrValue = getCurrentContext().getAttribute(name);

		if (attrValue != null) {
			return processObjectValue(attrValue);
		}

		return processAsDefinitionOrURL(name);
	}

	/**
	 * Process the url.
	 * @throws JspException If failed to create controller
	 */
	public TagHandler processUrl(String url) throws JspException {
		return new InsertHandler(url, role, getController());
	}

	/**
	 * Process tag attribute "definition".
	 * First, search definition in the factory, then create handler from this definition.
	 * @param name Name of the definition.
	 * @return Appropriate TagHandler.
	 * @throws JspException- NoSuchDefinitionException No Definition  found for name.
	 * @throws JspException- FactoryNotFoundException Can't find Definitions factory.
	 * @throws JspException- DefinedComponentFactoryException General error in factory.
	 * @throws JspException InstantiationException Can't create requested controller
	 */
	protected TagHandler processDefinitionName(String name)
		throws JspException {

		try {
			ComponentDefinition definition =
				TilesUtil.getDefinition(
					name,
					(HttpServletRequest) pageContext.getRequest(),
					pageContext.getServletContext());

			if (definition == null) { // is it possible ?
				throw new NoSuchDefinitionException();
			}

			return processDefinition(definition);

		} catch (NoSuchDefinitionException ex) {
			throw new JspException(
				"Error -  Tag Insert : Can't get definition '"
					+ definitionName
					+ "'. Check if this name exist in definitions factory.");

		} catch (FactoryNotFoundException ex) {
			throw new JspException(ex.getMessage());

		} catch (DefinitionsFactoryException ex) {
			if (log.isDebugEnabled()) {
				ex.printStackTrace();
			}

			// Save exception to be able to show it later
			pageContext.setAttribute(
				Globals.EXCEPTION_KEY,
				ex,
				PageContext.REQUEST_SCOPE);
			throw new JspException(ex.getMessage());
		}
	}

	/**
	 * End of Process tag attribute "definition".
	 * Overload definition with tag attributes "template" and "role".
	 * Then, create appropriate tag handler.
	 * @param definition Definition to process.
	 * @return Appropriate TagHandler.
	 * @throws JspException InstantiationException Can't create requested controller
	 */
	protected TagHandler processDefinition(ComponentDefinition definition)
		throws JspException {
		// Declare local variable in order to not change Tag attribute values.
		String role = this.role;
		String page = this.page;
		Controller controller = null;

		try {
			controller = definition.getOrCreateController();

			// Overload definition with tag's template and role.
			if (role == null) {
				role = definition.getRole();
			}

			if (page == null) {
				page = definition.getTemplate();
			}

			if (controllerName != null) {
				controller =
					ComponentDefinition.createController(
						controllerName,
						controllerType);
			}

			// Can check if page is set
			return new InsertHandler(
				definition.getAttributes(),
				page,
				role,
				controller);

		} catch (InstantiationException ex) {
			throw new JspException(ex.getMessage());
		}
	}

	/**
	 * Process a bean.
	 * Get bean value, eventually using property and scope. Found value is process by processObjectValue().
	 * @param beanName Name of the bean
	 * @param beanProperty Property in the bean, or null.
	 * @param beanScope bean scope, or null.
	 * @return Appropriate TagHandler.
	 * @throws JspException - NoSuchDefinitionException No value associated to bean.
	 * @throws JspException an error occur while reading bean, or no definition found.
	 * @throws JspException - Throws by underlying nested call to processDefinitionName()
	 */
	protected TagHandler processBean(
		String beanName,
		String beanProperty,
		String beanScope)
		throws JspException {

		Object beanValue =
			TagUtils.getRealValueFromBean(
				beanName,
				beanProperty,
				beanScope,
				pageContext);

		if (beanValue == null) {
			throw new JspException(
				"Error - Tag Insert : No value defined for bean '"
					+ beanName
					+ "' with property '"
					+ beanProperty
					+ "' in scope '"
					+ beanScope
					+ "'.");
		}

		return processObjectValue(beanValue);
	}

	/**
	 * Process tag attribute "attribute".
	 * Get value from component attribute.
	 * Found value is process by processObjectValue().
	 * @param name Name of the attribute.
	 * @return Appropriate TagHandler.
	 * @throws JspException - NoSuchDefinitionException No Definition  found for name.
	 * @throws JspException - Throws by underlying nested call to processDefinitionName()
	 */
	public TagHandler processAttribute(String name) throws JspException {
		Object attrValue = getCurrentContext().getAttribute(name);

		if (attrValue == null) {
			throw new JspException(
				"Error - Tag Insert : No value found for attribute '"
					+ name
					+ "'.");
		}

		return processObjectValue(attrValue);
	}

	/**
	 * Try to process name as a definition, or as an URL if not found.
	 * @param name Name to process.
	 * @return appropriate TagHandler
	 * @throws JspException InstantiationException Can't create requested controller
	 */
	public TagHandler processAsDefinitionOrURL(String name)
		throws JspException {
		try {
			ComponentDefinition definition =
				TilesUtil.getDefinition(
					name,
					pageContext.getRequest(),
					pageContext.getServletContext());

			if (definition != null) {
				return processDefinition(definition);
			}

		} catch (DefinitionsFactoryException ex) {
			// silently failed, because we can choose to not define a factory.
		}

		// no definition found, try as url
		return processUrl(name);
	}

	/**
	 * Process typed attribute according to its type.
	 * @param value Typed attribute to process.
	 * @return appropriate TagHandler.
	 * @throws JspException - Throws by underlying nested call to processDefinitionName()
	 */
	public TagHandler processTypedAttribute(AttributeDefinition value)
		throws JspException {
		if (value instanceof DirectStringAttribute) {
			return new DirectStringHandler((String) value.getValue());

		} else if (value instanceof DefinitionAttribute) {
			return processDefinition((ComponentDefinition) value.getValue());

		} else if (value instanceof DefinitionNameAttribute) {
			return processDefinitionName((String) value.getValue());
		}

		return new InsertHandler(
			(String) value.getValue(),
			role,
			getController());
	}

	/**
	 * Do an include of specified page.
	 * This method is used internally to do all includes from this class. It delegates
	 * the include call to the TilesUtil.doInclude().
	 * @param page The page that will be included
	 * @throws ServletException - Thrown by call to pageContext.include()
	 * @throws IOException - Thrown by call to pageContext.include()
	 */
	protected void doInclude(String page)
		throws ServletException, IOException {
		TilesUtil.doInclude(page, pageContext);
	}

	/////////////////////////////////////////////////////////////////////////////

	/**
	 * Inner Interface.
	 * Sub handler for tag.
	 */
	protected interface TagHandler {
		/**
		 * Create ComponentContext for type depicted by implementation class.
		 */
		public int doStartTag() throws JspException;
		/**
		 * Do include for type depicted by implementation class.
		 */
		public int doEndTag() throws JspException;
		/**
		 * Add a component parameter (attribute) to subContext.
		 */
		public void putAttribute(String name, Object value);
	} // end inner interface

	/////////////////////////////////////////////////////////////////////////////

	/**
	 * Real handler, after attribute resolution.
	 * Handle include sub-component.
	 */
	protected class InsertHandler implements TagHandler {
		protected String page;
		protected ComponentContext currentContext;
		protected ComponentContext subCompContext;
		protected String role;
		protected Controller controller;

		/**
		 * Constructor.
		 * Create insert handler using Component definition.
		 */
		public InsertHandler(
			Map attributes,
			String page,
			String role,
			Controller controller) {

			this.page = page;
			this.role = role;
			this.controller = controller;
			subCompContext = new ComponentContext(attributes);
		}

		/**
		 * Constructor.
		 * Create insert handler to insert page at specified location.
		 */
		public InsertHandler(String page, String role, Controller controller) {
			this.page = page;
			this.role = role;
			this.controller = controller;
			subCompContext = new ComponentContext();
		}

		/**
		 * Create a new empty context.
		 */
		public int doStartTag() throws JspException {
			// Check role
			HttpServletRequest request =
				(HttpServletRequest) pageContext.getRequest();

			if (role != null && !request.isUserInRole(role)) {
				return SKIP_BODY;
			}

			// save current context
			this.currentContext = getCurrentContext();
			return EVAL_BODY_INCLUDE;
		}

		/**
		 * Add attribute to sub context.
		 * Do nothing.
		 */
		public void putAttribute(String name, Object value) {
			subCompContext.putAttribute(name, value);
		}

		/**
		 * Include requested page.
		 */
		public int doEndTag() throws JspException {
			// Check role
			HttpServletRequest request =
				(HttpServletRequest) pageContext.getRequest();

			if (role != null && !request.isUserInRole(role)) {
				return EVAL_PAGE;
			}

			try {
				if (log.isDebugEnabled()) {
					log.debug("insert page='" + page + "'.");
				}

				// set new context for included component.
				pageContext.setAttribute(
					ComponentConstants.COMPONENT_CONTEXT,
					subCompContext,
					PageContext.REQUEST_SCOPE);

				// Call controller if any
				if (controller != null) {
					try {
						controller.execute(
							subCompContext,
							(HttpServletRequest) pageContext.getRequest(),
							(HttpServletResponse) pageContext.getResponse(),
							pageContext.getServletContext());
                            
					} catch (Exception e) {
						throw new ServletException(e);
					}

				}

				// include requested component.
				if (flush) {
					pageContext.getOut().flush();
				}

				doInclude(page);

			} catch (IOException e) {
				String msg =
					"Can't insert page '" + page + "' : " + e.getMessage();
				log.error(msg, e);
				throw new JspException(msg);

			} catch (IllegalArgumentException e) {
				// Can't resolve page uri, should we ignore it?
				if (!(page == null && isErrorIgnored)) {
					String msg =
						"Can't insert page '"
							+ page
							+ "'. Check if it exists.\n"
							+ e.getMessage();

					log.error(msg, e);
					throw new JspException(msg);
				}

			} catch (ServletException e) {
				Throwable cause = e;
				if (e.getRootCause() != null) {
					cause = e.getRootCause();
				}

				String msg =
					"ServletException in '" + page + "': " + cause.getMessage();

				log.error(msg, e);
				throw new JspException(msg);

			} finally {
				// restore old context only if currentContext not null 
				// (bug with Silverstream ?; related by Arvindra Sehmi 20010712)
				if (currentContext != null) {
					pageContext.setAttribute(
						ComponentConstants.COMPONENT_CONTEXT,
						currentContext,
						PageContext.REQUEST_SCOPE);
				}
			}

			return EVAL_PAGE;
		}

		/**
		 * Process an exception.
		 * Depending of debug attribute, print full exception trace or only
		 * its message in output page.
		 * @param ex Exception
		 * @param msg An additional message to show in console and to propagate if we can't output exception.
		 * @deprecated This method will be removed in a release after Struts 1.2.
		 */
		protected void processException(Throwable ex, String msg)
			throws JspException {

			try {
				if (msg == null) {
					msg = ex.getMessage();
				}

				if (log.isDebugEnabled()) { // show full trace
					log.debug(msg, ex);
					pageContext.getOut().println(msg);
					ex.printStackTrace(
						new PrintWriter(pageContext.getOut(), true));
				} else { // show only message
					pageContext.getOut().println(msg);
				}

			} catch (IOException ioex) { // problems. Propagate original exception
				pageContext.setAttribute(
					ComponentConstants.EXCEPTION_KEY,
					ex,
					PageContext.REQUEST_SCOPE);
				throw new JspException(msg);
			}
		}
	}

	/**
	 * Parse the list of roles and return <code>true</code> or <code>false</code> based on whether
	 * the user has that role or not.
	 * @param role Comma-delimited list of roles.
	 * @param request The request.
	 */
	static public boolean userHasRole(
		HttpServletRequest request,
		String role) {
		StringTokenizer st = new StringTokenizer(role, ",");
		while (st.hasMoreTokens()) {
			if (request.isUserInRole(st.nextToken())) {
				return true;
			}
		}

		return false;
	}

	/////////////////////////////////////////////////////////////////////////////

	/**
	 * Handle insert direct string.
	 */
	protected class DirectStringHandler implements TagHandler {
		/** Object to print as a direct string */
		private Object value;

		/**
		 * Constructor.
		 */
		public DirectStringHandler(Object value) {
			this.value = value;
		}

		/**
		 * Do nothing, there is no context for a direct string.
		 */
		public int doStartTag() throws JspException {
			return SKIP_BODY;
		}

		/**
		 * Add attribute to sub context.
		 * Do nothing.
		 */
		public void putAttribute(String name, Object value) {
		}

		/**
		 * Print String in page output stream.
		 */
		public int doEndTag() throws JspException {
			try {
				if (flush) {
					pageContext.getOut().flush();
				}

				pageContext.getOut().print(value);

			} catch (IOException ex) {
				if (log.isDebugEnabled()) {
					log.debug("Can't write string '" + value + "' : ", ex);
				}

				pageContext.setAttribute(
					ComponentConstants.EXCEPTION_KEY,
					ex,
					PageContext.REQUEST_SCOPE);

				throw new JspException(
					"Can't write string '" + value + "' : " + ex.getMessage());
			}

			return EVAL_PAGE;
		}
	}
}