Attachment #26304 for bug #50279

View | Details | Raw Unified | Return to bug 50279
Collapse All | Expand All

Lines 17-26 Link Here

(-)src/test/java/org/apache/taglibs/standard/VersionTest.java (-2 / +2 lines)
17		17
18	package org.apache.taglibs.standard;	18	package org.apache.taglibs.standard;
19		19
20	import junit.framework.*;	20	import junit.framework.TestCase;
21		21
22	public class VersionTest	22	public class VersionTest
23	extends TestCase {	23	extends TestCase {
24	private Version version = null;	24	private Version version = null;
25		25
26	public VersionTest(String name) {	26	public VersionTest(String name) {

Lines 16-30 Link Here

(-)src/test/java/org/apache/taglibs/standard/functions/FunctionsTest.java (-8 / +18 lines)
16	*/	16	*/
17	package org.apache.taglibs.standard.functions;	17	package org.apache.taglibs.standard.functions;
18		18
		19	import java.util.Arrays;
		20	import java.util.Collections;
		21
		22	import javax.servlet.jsp.JspTagException;
		23
19	import org.apache.taglibs.standard.resources.Resources;	24	import org.apache.taglibs.standard.resources.Resources;
20	import org.junit.Assert;	25	import org.junit.Assert;
21	import org.junit.Test;	26	import org.junit.Test;
22		27
23	import javax.servlet.jsp.JspTagException;	28	import static org.apache.taglibs.standard.functions.Functions.endsWith;
24	import java.util.Arrays;	29	import static org.apache.taglibs.standard.functions.Functions.escapeXml;
25	import java.util.Collections;	30	import static org.apache.taglibs.standard.functions.Functions.join;
		31	import static org.apache.taglibs.standard.functions.Functions.length;
		32	import static org.apache.taglibs.standard.functions.Functions.replace;
		33	import static org.apache.taglibs.standard.functions.Functions.split;
		34	import static org.apache.taglibs.standard.functions.Functions.substring;
		35	import static org.apache.taglibs.standard.functions.Functions.substringAfter;
		36	import static org.apache.taglibs.standard.functions.Functions.substringBefore;
26		37
27	import static org.apache.taglibs.standard.functions.Functions.*;
28	/**	38	/**
29	*/	39	*/
30	public class FunctionsTest {	40	public class FunctionsTest {
Lines 104-113 Link Here
104	public void testLength() throws Exception {	114	public void testLength() throws Exception {
105	Assert.assertEquals(0, length(null));	115	Assert.assertEquals(0, length(null));
106	Assert.assertEquals(0, length(""));	116	Assert.assertEquals(0, length(""));
107	Assert.assertEquals(3, length(new int[]{1,2,3}));	117	Assert.assertEquals(3, length(new int[]{1, 2, 3}));
108	Assert.assertEquals(3, length(Arrays.asList(1,2,3)));	118	Assert.assertEquals(3, length(Arrays.asList(1, 2, 3)));
109	Assert.assertEquals(3, length(Arrays.asList(1,2,3).iterator()));	119	Assert.assertEquals(3, length(Arrays.asList(1, 2, 3).iterator()));
110	Assert.assertEquals(3, length(Collections.enumeration(Arrays.asList(1,2,3))));	120	Assert.assertEquals(3, length(Collections.enumeration(Arrays.asList(1, 2, 3))));
111	Assert.assertEquals(1, length(Collections.singletonMap("Hello", "World")));	121	Assert.assertEquals(1, length(Collections.singletonMap("Hello", "World")));
112	try {	122	try {
113	length(3);	123	length(3);

Lines 36-41 Link Here

(-)src/test/java/org/apache/taglibs/standard/tag/common/fmt/BundleSupportTest.java (+1 lines)
36	}	36	}
37		37
38	// test for bugzilla #49900 that bodyContent is not released	38	// test for bugzilla #49900 that bodyContent is not released
		39
39	@Test	40	@Test
40	public void testBodyContentIsRelease() {	41	public void testBodyContentIsRelease() {
41	BodyContent b = EasyMock.createMock(BodyContent.class);	42	BodyContent b = EasyMock.createMock(BodyContent.class);




 */
package org.apache.taglibs.standard.tag.common.core;

import java.util.Map;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import javax.el.ELContext;
import javax.el.ExpressionFactory;

import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.BodyContent;

import org.apache.taglibs.standard.resources.Resources;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;




 */
package org.apache.taglibs.standard.util;

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;

import javax.servlet.jsp.JspWriter;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import static org.apache.taglibs.standard.util.EscapeXML.emit;
import static org.apache.taglibs.standard.util.EscapeXML.escape;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;

import static org.apache.taglibs.standard.util.EscapeXML.*;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.eq;
import static org.easymock.EasyMock.expect;




 * 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.taglibs.standard.tei;


public class DeclareTEI extends TagExtraInfo {

    // purposely inherit JavaDoc and semantics from TagExtraInfo

    @Override
    public VariableInfo[] getVariableInfo(TagData data) {
        // construct the relevant VariableInfo object
        VariableInfo id = new VariableInfo(
                data.getAttributeString("id"),
                data.getAttributeString("type") == null ?
                        "java.lang.Object" : data.getAttributeString("type"),
                true,
                VariableInfo.AT_END);
        return new VariableInfo[]{id};
    }
}

Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tei/ForEachTEI.java (-3 / +6 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17		17
18	package org.apache.taglibs.standard.tei;	18	package org.apache.taglibs.standard.tei;
19		19
Lines 37-47 Link Here
37	*	37	*
38	* - If 'items' is not specified, 'begin' and 'end' must be	38	* - If 'items' is not specified, 'begin' and 'end' must be
39	*/	39	*/
		40
40	@Override	41	@Override
41	public boolean isValid(TagData us) {	42	public boolean isValid(TagData us) {
42	if (!Util.isSpecified(us, ITEMS))	43	if (!Util.isSpecified(us, ITEMS)) {
43	if (!Util.isSpecified(us, BEGIN) \|\| !(Util.isSpecified(us, END)))	44	if (!Util.isSpecified(us, BEGIN) \|\| !(Util.isSpecified(us, END))) {
44	return false;	45	return false;
		46	}
		47	}
45	return true;	48	return true;
46	}	49	}
47		50




 * 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.taglibs.standard.tei;



    @Override
    public boolean isValid(TagData us) {
        // don't allow both VAR and VAR_READER, together
        if (Util.isSpecified(us, VAR) && Util.isSpecified(us, VAR_READER)) {
            return false;
        }

        return true;
    }

Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tei/Util.java (-1 / +1 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17		17
18	package org.apache.taglibs.standard.tei;	18	package org.apache.taglibs.standard.tei;
19		19




 * 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.taglibs.standard.tei;



    @Override
    public boolean isValid(TagData us) {
        // must have no more than one of VAR and VAR_DOM ...
        if (Util.isSpecified(us, VAR) && Util.isSpecified(us, VAR_DOM)) {
            return false;
        }

        // ... and must have no less than one of VAR and VAR_DOM
        if (!(Util.isSpecified(us, VAR) || Util.isSpecified(us, VAR_DOM))) {
            return false;
        }

        // When either 'scope' is specified, its 'var' must be specified
        if (Util.isSpecified(us, SCOPE) && !Util.isSpecified(us, VAR)) {
            return false;
        }
        if (Util.isSpecified(us, SCOPE_DOM) && !Util.isSpecified(us, VAR_DOM)) {
            return false;
        }

        return true;
    }




 * 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.taglibs.standard.tei;



    @Override
    public boolean isValid(TagData us) {
        // require XSLT
        if (!Util.isSpecified(us, XSLT)) {
            return false;
        }

        // disallow both VAR and RESULT
        if (Util.isSpecified(us, VAR) && Util.isSpecified(us, RESULT)) {
            return false;
        }
        return true;
    }





 * 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.taglibs.standard;


 * Administrative class to keep track of the version number of
 * the standard tag library.
 * <P>This class implements the upcoming standard of having
 * org.apache.project-name.Version.getVersion() be a standard way
 * to get version information.
 */
public class Version {
    /**
     * Get the basic version string for the current release.
     * Version String formatted like
     * <CODE>"<B>standard-taglib</B> v.r[.dd| <B>D</B>nn]"</CODE>.
     * <p/>
     * Futurework: have this read version info from jar manifest.
     *
     * @return String denoting our current version
     */
    public static String getVersion() {
        return getProduct() + " " +
                getMajorVersionNum() + "." + getReleaseVersionNum() + "." +
                getMaintenanceVersionNum() +
                ((getDevelopmentVersionNum() > 0) ?
                        ("_D" + getDevelopmentVersionNum()) : "");
    }
               ("_D" + getDevelopmentVersionNum()) : "");
  }

    /**
     * Print the processor version to the command line.
     *
     * @param argv command line arguments, unused.
     */
    public static void main(String argv[]) {
        System.out.println(getVersion());
    }
  }

    /**
     * Name of product
     */
    public static String getProduct() {
        return "standard-taglib";
    }
  }

    /**
     * Major version number.
     * Version number. This changes only when there is a
     * significant, externally apparent enhancement from
     * the previous release. 'n' represents the n'th
     * version.
     * <p/>
     * Clients should carefully consider the implications
     * of new versions as external interfaces and behaviour
     * may have changed.
     */
    public static int getMajorVersionNum() {
        return 1;
    }
  }

    /**
     * Release Number.
     * Release number. This changes when:
     * -  a new set of functionality is to be added, eg,
     * implementation of a new W3C specification.
     * -  API or behaviour change.
     * -  its designated as a reference release.
     */
    public static int getReleaseVersionNum() {
        return 2;
    }
  }

    /**
     * Maintenance Drop Number.
     * Optional identifier used to designate maintenance
     * drop applied to a specific release and contains
     * fixes for defects reported. It maintains compatibility
     * with the release and contains no API changes.
     * When missing, it designates the final and complete
     * development drop for a release.
     */
    public static int getMaintenanceVersionNum() {
        return 0;
    }
  }

    /**
     * Development Drop Number.
     * Optional identifier designates development drop of
     * a specific release. D01 is the first development drop
     * of a new release.
     * <p/>
     * Development drops are works in progress towards a
     * compeleted, final release. A specific development drop
     * may not completely implement all aspects of a new
     * feature, which may take several development drops to
     * complete. At the point of the final drop for the
     * release, the D suffix will be omitted.
     * <p/>
     * Each 'D' drops can contain functional enhancements as
     * well as defect fixes. 'D' drops may not be as stable as
     * the final releases.
     */
    public static int getDevelopmentVersionNum() {
        return 0;
    }
  }
}




 * 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.taglibs.standard.tlv;



/**
 * <p>A SAX-based TagLibraryValidator for the JSTL SQL tag library.
 *
 * @author Shawn Bayern
 */
public class JstlSqlTLV extends JstlBaseTLV {


    //*********************************************************************
    // set its type and delegate validation to super-class

    @Override
    public ValidationMessage[] validate(
            String prefix, String uri, PageData page) {
        return super.validate(TYPE_SQL, prefix, uri, page);
    }




    @Override
    protected DefaultHandler getHandler() {
        return new Handler();
    }


    //*********************************************************************
    // SAX event handler

    /**
     * The handler that provides the base of our implementation.
     */
    private class Handler extends DefaultHandler {

        // parser state
        private int depth = 0;
        private Stack queryDepths = new Stack();
        private Stack updateDepths = new Stack();
        private Stack transactionDepths = new Stack();
        private String lastElementName = null;
        private boolean bodyNecessary = false;
        private boolean bodyIllegal = false;

        // process under the existing context (state), then modify it
	@Override
    public void startElement(
	        String ns, String ln, String qn, Attributes a) {

        @Override
        public void startElement(
                String ns, String ln, String qn, Attributes a) {

            // substitute our own parsed 'ln' if it's not provided
            if (ln == null) {
                ln = getLocalPart(qn);
            }

            // for simplicity, we can ignore <jsp:text> for our purposes
            // (don't bother distinguishing between it and its characters)
            if (qn.equals(JSP_TEXT)) {
                return;
            }

            // check body-related constraint
            if (bodyIllegal) {
                fail(Resources.getMessage("TLV_ILLEGAL_BODY", lastElementName));
            }
		for (int i = 0; i < a.getLength(); i++) {
		    String attName = a.getLocalName(i);
		    if (expAtts.contains(attName)) {
			String vMsg =
			    validateExpression(
				ln,
				attName,
				a.getValue(i));
			if (vMsg != null)
			    fail(vMsg);
		    }
		}
	    }

            // validate expression syntax if we need to
            Set expAtts;
            if (qn.startsWith(prefix + ":")
                    && (expAtts = (Set) config.get(ln)) != null) {
                for (int i = 0; i < a.getLength(); i++) {
                    String attName = a.getLocalName(i);
                    if (expAtts.contains(attName)) {
                        String vMsg =
                                validateExpression(
                                        ln,
                                        attName,
                                        a.getValue(i));
                        if (vMsg != null) {
                            fail(vMsg);
                        }
                    }
                }
            }

            // validate attributes
            if (qn.startsWith(prefix + ":") && !hasNoInvalidScope(a)) {
                fail(Resources.getMessage("TLV_INVALID_ATTRIBUTE",
                        SCOPE, qn, a.getValue(SCOPE)));
            }
            if (qn.startsWith(prefix + ":") && hasEmptyVar(a)) {
                fail(Resources.getMessage("TLV_EMPTY_VAR", qn));
            }
            if (qn.startsWith(prefix + ":") && hasDanglingScope(a) &&
                    !qn.startsWith(prefix + ":" + SETDATASOURCE)) {
                fail(Resources.getMessage("TLV_DANGLING_SCOPE", qn));
            }

            // now, modify state

            /*
             * Make sure <sql:param> is nested inside <sql:query> or

             *   </c:forEach>
             *  </sql:query>
             */
            if ((isSqlTag(ns, ln, PARAM) || isSqlTag(ns, ln, DATEPARAM))
                    && (queryDepths.empty() && updateDepths.empty())) {
                fail(Resources.getMessage("SQL_PARAM_OUTSIDE_PARENT"));
            }


                transactionDepths.push(new Integer(depth));
            }

            // set up a check against illegal attribute/body combinations
            bodyIllegal = false;
            bodyNecessary = false;

            if (isSqlTag(ns, ln, QUERY) || isSqlTag(ns, ln, UPDATE)) {
                if (!hasAttribute(a, SQL)) {

                bodyIllegal = true;
            }

            // record the most recent tag (for error reporting)
            lastElementName = qn;
            lastElementId = a.getValue("http://java.sun.com/JSP/Page", "id");

            // we're a new element, so increase depth
            depth++;
        }

        @Override
        public void characters(char[] ch, int start, int length) {

            bodyNecessary = false;        // body is no longer necessary!

            // ignore strings that are just whitespace
            String s = new String(ch, start, length).trim();
            if (s.equals("")) {
                return;
            }

            // check and update body-related constraints
            if (bodyIllegal) {
                fail(Resources.getMessage("TLV_ILLEGAL_BODY", lastElementName));
            }
        }

        @Override
        public void endElement(String ns, String ln, String qn) {

            // consistently, we ignore JSP_TEXT
            if (qn.equals(JSP_TEXT)) {
                return;
            }

            // handle body-related invariant
            if (bodyNecessary) {
                fail(Resources.getMessage("TLV_MISSING_BODY",
                        lastElementName));
            }
            bodyIllegal = false;    // reset: we've left the tag

            // update <query>-related state
            if (isSqlTag(ns, ln, QUERY)) {

                transactionDepths.pop();
            }

            // update our depth
            depth--;
        }
    }
}




 * 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.taglibs.standard.tlv;


/**
 * <p>A SAX-based TagLibraryValidator for the JSTL XML library.
 * Currently implements the following checks:</p>
 * <p/>
 * <ul>
 * <li>Expression syntax validation.
 * <li>Choose / when / otherwise constraints</li>
 * <li>Tag bodies that must either be empty or non-empty given
 * particular attributes.</li>
 * <li>Other minor constraints.</li>
 * </ul>
 *
 * @author Shawn Bayern
 */
public class JstlXmlTLV extends JstlBaseTLV {


    //*********************************************************************
    // set its type and delegate validation to super-class

    @Override
    public ValidationMessage[] validate(
            String prefix, String uri, PageData page) {
        return super.validate(TYPE_XML, prefix, uri, page);
    }




    @Override
    protected DefaultHandler getHandler() {
        return new Handler();
    }


    //*********************************************************************
    // SAX event handler

    /**
     * The handler that provides the base of our implementation.
     */
    private class Handler extends DefaultHandler {

        // parser state
        private int depth = 0;
        private Stack chooseDepths = new Stack();
        private Stack chooseHasOtherwise = new Stack();
        private Stack chooseHasWhen = new Stack();
        private String lastElementName = null;
        private boolean bodyNecessary = false;
        private boolean bodyIllegal = false;
        private Stack transformWithSource = new Stack();

        // process under the existing context (state), then modify it
	@Override
    public void startElement(
	        String ns, String ln, String qn, Attributes a) {

        @Override
        public void startElement(
                String ns, String ln, String qn, Attributes a) {

            // substitute our own parsed 'ln' if it's not provided
            if (ln == null) {
                ln = getLocalPart(qn);
            }

            // for simplicity, we can ignore <jsp:text> for our purposes
            // (don't bother distinguishing between it and its characters)
            if (qn.equals(JSP_TEXT)) {
                return;
            }

            // check body-related constraint
            if (bodyIllegal) {
                fail(Resources.getMessage("TLV_ILLEGAL_BODY", lastElementName));
            }

            // validate expression syntax if we need to
            Set expAtts;

                    String attName = a.getLocalName(i);
                    if (expAtts.contains(attName)) {
                        String vMsg =
                                validateExpression(
                                        ln,
                                        attName,
                                        a.getValue(i));
                        if (vMsg != null) {
                            fail(vMsg);
                        }
                    }
                }
            }

            // validate attributes
            if (qn.startsWith(prefix + ":") && !hasNoInvalidScope(a)) {
                fail(Resources.getMessage("TLV_INVALID_ATTRIBUTE",
                        SCOPE, qn, a.getValue(SCOPE)));
            }
            if (qn.startsWith(prefix + ":") && hasEmptyVar(a)) {
                fail(Resources.getMessage("TLV_EMPTY_VAR", qn));
            }
            if (qn.startsWith(prefix + ":") && hasDanglingScope(a)) {
                fail(Resources.getMessage("TLV_DANGLING_SCOPE", qn));
            }

            // check invariants for <choose>
            if (chooseChild()) {
                // mark <choose> for the first the first <when>
                if (isXmlTag(ns, ln, WHEN)) {
                    chooseHasWhen.pop();
                    chooseHasWhen.push(Boolean.TRUE);
                }

                // ensure <choose> has the right children
                if (!isXmlTag(ns, ln, WHEN) && !isXmlTag(ns, ln, OTHERWISE)) {
                    fail(Resources.getMessage("TLV_ILLEGAL_CHILD_TAG",
                            prefix, CHOOSE, qn));
                }

                // make sure <otherwise> is the last tag
                if (((Boolean) chooseHasOtherwise.peek()).booleanValue()) {
                    fail(Resources.getMessage("TLV_ILLEGAL_ORDER",
                            qn, prefix, OTHERWISE, CHOOSE));
                }
                if (isXmlTag(ns, ln, OTHERWISE)) {
                    chooseHasOtherwise.pop();
                    chooseHasOtherwise.push(Boolean.TRUE);
                }

            }

            // Specific check, directly inside <transform source="...">
            if (!transformWithSource.empty() &&
                    topDepth(transformWithSource) == (depth - 1)) {
                // only allow <param>
                if (!isXmlTag(ns, ln, PARAM)) {
                    fail(Resources.getMessage("TLV_ILLEGAL_BODY",
                            prefix + ":" + TRANSFORM));
                }

                // thus, if we get the opportunity to hit depth++,
                // we know we've got a <param> subtag
            }

            // now, modify state

            // we're a choose, so record new choose-specific state
            if (isXmlTag(ns, ln, CHOOSE)) {
                chooseDepths.push(new Integer(depth));
                chooseHasWhen.push(Boolean.FALSE);
                chooseHasOtherwise.push(Boolean.FALSE);
            }

            // set up a check against illegal attribute/body combinations
            bodyIllegal = false;
            bodyNecessary = false;
            if (isXmlTag(ns, ln, PARSE)) {
                if (hasAttribute(a, SOURCE)) {
                    bodyIllegal = true;
                }
            } else if (isXmlTag(ns, ln, PARAM)) {
                if (hasAttribute(a, VALUE)) {
                    bodyIllegal = true;
                } else {
                    bodyNecessary = true;
                }
            } else if (isXmlTag(ns, ln, TRANSFORM)) {
                if (hasAttribute(a, SOURCE)) {
                    transformWithSource.push(new Integer(depth));
                }
            }

            // record the most recent tag (for error reporting)
            lastElementName = qn;
            lastElementId = a.getValue("http://java.sun.com/JSP/Page", "id");

            // we're a new element, so increase depth
            depth++;
        }

        @Override
        public void characters(char[] ch, int start, int length) {

            bodyNecessary = false;        // body is no longer necessary!

            // ignore strings that are just whitespace
            String s = new String(ch, start, length).trim();
            if (s.equals("")) {
                return;
            }

            // check and update body-related constraints
            if (bodyIllegal) {
                fail(Resources.getMessage("TLV_ILLEGAL_BODY", lastElementName));
            }

            // make sure <choose> has no non-whitespace text
            if (chooseChild()) {
                String msg =
                        Resources.getMessage("TLV_ILLEGAL_TEXT_BODY",
                                prefix, CHOOSE,
                                (s.length() < 7 ? s : s.substring(0, 7)));
                fail(msg);
            }

            // Specific check, directly inside <transform source="...">
            if (!transformWithSource.empty()
                    && topDepth(transformWithSource) == (depth - 1)) {
                fail(Resources.getMessage("TLV_ILLEGAL_BODY",
                        prefix + ":" + TRANSFORM));
            }
        }

        @Override
        public void endElement(String ns, String ln, String qn) {

            // consistently, we ignore JSP_TEXT
            if (qn.equals(JSP_TEXT)) {
                return;
            }

            // handle body-related invariant
            if (bodyNecessary) {
                fail(Resources.getMessage("TLV_MISSING_BODY",
                        lastElementName));
            }
            bodyIllegal = false;    // reset: we've left the tag

            // update <choose>-related state
            if (isXmlTag(ns, ln, CHOOSE)) {
                Boolean b = (Boolean) chooseHasWhen.pop();
                if (!b.booleanValue()) {
                    fail(Resources.getMessage("TLV_PARENT_WITHOUT_SUBTAG",
                            CHOOSE, WHEN));
                }
                chooseDepths.pop();
                chooseHasOtherwise.pop();
            }

            // update <transform source="...">-related state
            if (!transformWithSource.empty()
                    && topDepth(transformWithSource) == (depth - 1)) {
                transformWithSource.pop();
            }

            // update our depth
            depth--;
        }

        // are we directly under a <choose>?
	private boolean chooseChild() {
	    return (!chooseDepths.empty()
		&& (depth - 1) == ((Integer) chooseDepths.peek()).intValue());
	}

        private boolean chooseChild() {
            return (!chooseDepths.empty()
                    && (depth - 1) == ((Integer) chooseDepths.peek()).intValue());
        }

        // returns the top int depth (peeked at) from a Stack of Integer

        private int topDepth(Stack s) {
            return ((Integer) s.peek()).intValue();
        }




 * 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.taglibs.standard.tlv;


/**
 * <p>A SAX-based TagLibraryValidator for the JSTL i18n-capable formatting
 * library. Currently implements the following checks:</p>
 * <p/>
 * <ul>
 * <li>Expression syntax validation.
 * <li>Tag bodies that must either be empty or non-empty given
 * particular attributes.</li>
 * </ul>
 *
 * @author Shawn Bayern
 * @author Jan Luehe
 */


    //*********************************************************************
    // set its type and delegate validation to super-class

    @Override
    public ValidationMessage[] validate(
            String prefix, String uri, PageData page) {
        return super.validate(TYPE_FMT, prefix, uri, page);
    }




    @Override
    protected DefaultHandler getHandler() {
        return new Handler();
    }


    //*********************************************************************
    // SAX event handler

    /**
     * The handler that provides the base of our implementation.
     */
    private class Handler extends DefaultHandler {

        // parser state
        private int depth = 0;
        private Stack messageDepths = new Stack();
        private String lastElementName = null;
        private boolean bodyNecessary = false;
        private boolean bodyIllegal = false;

        // process under the existing context (state), then modify it
	@Override
    public void startElement(
	        String ns, String ln, String qn, Attributes a) {

        @Override
        public void startElement(
                String ns, String ln, String qn, Attributes a) {

            // substitute our own parsed 'ln' if it's not provided
            if (ln == null) {
                ln = getLocalPart(qn);
            }

            // for simplicity, we can ignore <jsp:text> for our purposes
            // (don't bother distinguishing between it and its characters)
            if (qn.equals(JSP_TEXT)) {
                return;
            }

            // check body-related constraint
            if (bodyIllegal) {
                fail(Resources.getMessage("TLV_ILLEGAL_BODY",
                        lastElementName));
            }

            // validate expression syntax if we need to
            Set expAtts;

                    String attName = a.getLocalName(i);
                    if (expAtts.contains(attName)) {
                        String vMsg =
                                validateExpression(
                                        ln,
                                        attName,
                                        a.getValue(i));
                        if (vMsg != null) {
                            fail(vMsg);
                        }
                    }
                }
            }

            // validate attributes
            if (qn.startsWith(prefix + ":") && !hasNoInvalidScope(a)) {
                fail(Resources.getMessage("TLV_INVALID_ATTRIBUTE",
                        SCOPE, qn, a.getValue(SCOPE)));
            }
            if (qn.startsWith(prefix + ":") && hasEmptyVar(a)) {
                fail(Resources.getMessage("TLV_EMPTY_VAR", qn));
            }
            if (qn.startsWith(prefix + ":")
                    && !isFmtTag(ns, ln, SETLOCALE)
                    && !isFmtTag(ns, ln, SETBUNDLE)
                    && !isFmtTag(ns, ln, SETTIMEZONE)
                    && hasDanglingScope(a)) {
                fail(Resources.getMessage("TLV_DANGLING_SCOPE", qn));
            }

            /*
            * Make sure <fmt:param> is nested inside <fmt:message>. Note that
            * <fmt:param> does not need to be a direct child of <fmt:message>.
            * Otherwise, the following would not work:
            *
            *  <fmt:message key="..." bundle="...">
            *   <c:forEach var="arg" items="...">
            *    <fmt:param value="${arg}"/>
            *   </c:forEach>
            *  </fmt:message>
            */
            if (isFmtTag(ns, ln, MESSAGE_PARAM) && messageDepths.empty()) {
                fail(Resources.getMessage("PARAM_OUTSIDE_MESSAGE"));
            }

            // now, modify state

            // If we're in a <message>, record relevant state
            if (isFmtTag(ns, ln, MESSAGE)) {
                messageDepths.push(new Integer(depth));
            }

            // set up a check against illegal attribute/body combinations
            bodyIllegal = false;
            bodyNecessary = false;
            if (isFmtTag(ns, ln, MESSAGE_PARAM)
                    || isFmtTag(ns, ln, FORMAT_NUMBER)
                    || isFmtTag(ns, ln, PARSE_NUMBER)
                    || isFmtTag(ns, ln, PARSE_DATE)) {
                if (hasAttribute(a, VALUE)) {
                    bodyIllegal = true;
                } else {
                    bodyNecessary = true;
                }
            } else if (isFmtTag(ns, ln, MESSAGE)
                    && !hasAttribute(a, MESSAGE_KEY)) {
                bodyNecessary = true;
            } else if (isFmtTag(ns, ln, BUNDLE)
                    && hasAttribute(a, BUNDLE_PREFIX)) {
                bodyNecessary = true;
            }

            // record the most recent tag (for error reporting)
            lastElementName = qn;
            lastElementId = a.getValue(JSP, "id");

            // we're a new element, so increase depth
            depth++;
        }

        @Override
        public void characters(char[] ch, int start, int length) {

            bodyNecessary = false;        // body is no longer necessary!

            // ignore strings that are just whitespace
            String s = new String(ch, start, length).trim();
            if (s.equals("")) {
                return;
            }

            // check and update body-related constraints
            if (bodyIllegal) {
                fail(Resources.getMessage("TLV_ILLEGAL_BODY",
                        lastElementName));
            }
        }

        @Override
        public void endElement(String ns, String ln, String qn) {

            // consistently, we ignore JSP_TEXT
            if (qn.equals(JSP_TEXT)) {
                return;
            }

            // handle body-related invariant
            if (bodyNecessary) {
                fail(Resources.getMessage("TLV_MISSING_BODY",
                        lastElementName));
            }
            bodyIllegal = false;    // reset: we've left the tag

            // update <message>-related state
            if (isFmtTag(ns, ln, MESSAGE)) {
                messageDepths.pop();
            }

            // update our depth
            depth--;
        }
    }
}




 * 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.taglibs.standard.tlv;


/**
 * <p>A SAX-based TagLibraryValidator for the core JSTL tag library.
 * Currently implements the following checks:</p>
 * <p/>
 * <ul>
 * <li>Expression syntax validation.
 * <li>Choose / when / otherwise constraints</li>
 * <li>Tag bodies that must either be empty or non-empty given
 * particular attributes.  (E.g., <set> cannot have a body when
 * 'value' is specified; it *must* have a body otherwise.)  For
 * these purposes, "having a body" refers to non-whitespace
 * content inside the tag.</li>
 * <li>Other minor constraints.</li>
 * </ul>
 *
 * @author Shawn Bayern
 */
public class JstlCoreTLV extends JstlBaseTLV {


    //*********************************************************************
    // set its type and delegate validation to super-class

    @Override
    public ValidationMessage[] validate(
            String prefix, String uri, PageData page) {
        return super.validate(TYPE_CORE, prefix, uri, page);
    }




    @Override
    protected DefaultHandler getHandler() {
        return new Handler();
    }


    //*********************************************************************
    // SAX event handler

    /**
     * The handler that provides the base of our implementation.
     */
    private class Handler extends DefaultHandler {

        // parser state
        private int depth = 0;
        private Stack chooseDepths = new Stack();
        private Stack chooseHasOtherwise = new Stack();
        private Stack chooseHasWhen = new Stack();
        private Stack urlTags = new Stack();
        private String lastElementName = null;
        private boolean bodyNecessary = false;
        private boolean bodyIllegal = false;

        // process under the existing context (state), then modify it
	@Override
    public void startElement(
	        String ns, String ln, String qn, Attributes a) {

        @Override
        public void startElement(
                String ns, String ln, String qn, Attributes a) {

            // substitute our own parsed 'ln' if it's not provided
            if (ln == null) {
                ln = getLocalPart(qn);
            }

            // for simplicity, we can ignore <jsp:text> for our purposes
            // (don't bother distinguishing between it and its characters)
            if (isJspTag(ns, ln, TEXT)) {
                return;
            }

            // check body-related constraint
            if (bodyIllegal) {
                fail(Resources.getMessage("TLV_ILLEGAL_BODY", lastElementName));
            }
		for (int i = 0; i < a.getLength(); i++) {
		    String attName = a.getLocalName(i);
		    if (expAtts.contains(attName)) {
			String vMsg =
			    validateExpression(
				ln,
				attName,
				a.getValue(i));
			if (vMsg != null)
			    fail(vMsg);
		    }
		}
	    }

            // validate expression syntax if we need to
            Set expAtts;
            if (qn.startsWith(prefix + ":")
                    && (expAtts = (Set) config.get(ln)) != null) {
                for (int i = 0; i < a.getLength(); i++) {
                    String attName = a.getLocalName(i);
                    if (expAtts.contains(attName)) {
                        String vMsg =
                                validateExpression(
                                        ln,
                                        attName,
                                        a.getValue(i));
                        if (vMsg != null) {
                            fail(vMsg);
                        }
                    }
                }
            }

            // validate attributes
            if (qn.startsWith(prefix + ":") && !hasNoInvalidScope(a)) {
                fail(Resources.getMessage("TLV_INVALID_ATTRIBUTE",
                        SCOPE, qn, a.getValue(SCOPE)));
            }
            if (qn.startsWith(prefix + ":") && hasEmptyVar(a)) {
                fail(Resources.getMessage("TLV_EMPTY_VAR", qn));
            }
            if (qn.startsWith(prefix + ":") && hasDanglingScope(a)) {
                fail(Resources.getMessage("TLV_DANGLING_SCOPE", qn));
            }

            // check invariants for <choose>
            if (chooseChild()) {
                // mark <choose> for the first the first <when>
                if (isCoreTag(ns, ln, WHEN)) {
                    chooseHasWhen.pop();
                    chooseHasWhen.push(Boolean.TRUE);
                }

                // ensure <choose> has the right children
                if (!isCoreTag(ns, ln, WHEN) && !isCoreTag(ns, ln, OTHERWISE)) {
                    fail(Resources.getMessage("TLV_ILLEGAL_CHILD_TAG",
                            prefix, CHOOSE, qn));
                }

                // make sure <otherwise> is the last tag
                if (((Boolean) chooseHasOtherwise.peek()).booleanValue()) {
                    fail(Resources.getMessage("TLV_ILLEGAL_ORDER",
                            qn, prefix, OTHERWISE, CHOOSE));
                }
                if (isCoreTag(ns, ln, OTHERWISE)) {
                    chooseHasOtherwise.pop();
                    chooseHasOtherwise.push(Boolean.TRUE);
                }

            }

            // check constraints for <param> vis-a-vis URL-related tags
            if (isCoreTag(ns, ln, PARAM)) {
                // no <param> outside URL tags.
                if (urlTags.empty() || urlTags.peek().equals(PARAM)) {
                    fail(Resources.getMessage("TLV_ILLEGAL_ORPHAN", PARAM));
                }

                // no <param> where the most recent <import> has a reader
                if (!urlTags.empty() &&
                        urlTags.peek().equals(IMPORT_WITH_READER)) {
                    fail(Resources.getMessage("TLV_ILLEGAL_PARAM",
                            prefix, PARAM, IMPORT, VAR_READER));
                }
            } else {
                // tag ISN'T <param>, so it's illegal under non-reader <import>
                if (!urlTags.empty()
                        && urlTags.peek().equals(IMPORT_WITHOUT_READER)) {
                    fail(Resources.getMessage("TLV_ILLEGAL_CHILD_TAG",
                            prefix, IMPORT, qn));
                }
            }

            // now, modify state

            // we're a choose, so record new choose-specific state
            if (isCoreTag(ns, ln, CHOOSE)) {
                chooseDepths.push(new Integer(depth));
                chooseHasWhen.push(Boolean.FALSE);
                chooseHasOtherwise.push(Boolean.FALSE);
            }

            // if we're introducing a URL-related tag, record it
            if (isCoreTag(ns, ln, IMPORT)) {
                if (hasAttribute(a, VAR_READER)) {
                    urlTags.push(IMPORT_WITH_READER);
                } else {
                    urlTags.push(IMPORT_WITHOUT_READER);
                }
            } else if (isCoreTag(ns, ln, PARAM)) {
                urlTags.push(PARAM);
            } else if (isCoreTag(ns, ln, REDIRECT)) {
                urlTags.push(REDIRECT);
            } else if (isCoreTag(ns, ln, URL)) {
                urlTags.push(URL);
            }

            // set up a check against illegal attribute/body combinations
            bodyIllegal = false;
            bodyNecessary = false;
            if (isCoreTag(ns, ln, EXPR)) {
                if (hasAttribute(a, DEFAULT)) {
                    bodyIllegal = true;
                }
            } else if (isCoreTag(ns, ln, SET)) {
                if (hasAttribute(a, VALUE)) {
                    bodyIllegal = true;
                }
                // else
                //    bodyNecessary = true;
            }

            // record the most recent tag (for error reporting)
            lastElementName = qn;
            lastElementId = a.getValue(JSP, "id");

            // we're a new element, so increase depth
            depth++;
        }

        @Override
        public void characters(char[] ch, int start, int length) {

            bodyNecessary = false;        // body is no longer necessary!

            // ignore strings that are just whitespace
            String s = new String(ch, start, length).trim();
            if (s.equals("")) {
                return;
            }

            // check and update body-related constraints
            if (bodyIllegal) {
                fail(Resources.getMessage("TLV_ILLEGAL_BODY", lastElementName));
            }
            if (!urlTags.empty()
                    && urlTags.peek().equals(IMPORT_WITHOUT_READER)) {
                // we're in an <import> without a Reader; nothing but
                // <param> is allowed
                fail(Resources.getMessage("TLV_ILLEGAL_BODY",
                        prefix + ":" + IMPORT));
            }

            // make sure <choose> has no non-whitespace text
            if (chooseChild()) {
                String msg =
                        Resources.getMessage("TLV_ILLEGAL_TEXT_BODY",
                                prefix, CHOOSE,
                                (s.length() < 7 ? s : s.substring(0, 7)));
                fail(msg);
            }
        }

        @Override
        public void endElement(String ns, String ln, String qn) {

            // consistently, we ignore JSP_TEXT
            if (isJspTag(ns, ln, TEXT)) {
                return;
            }

            // handle body-related invariant
            if (bodyNecessary) {
                fail(Resources.getMessage("TLV_MISSING_BODY",
                        lastElementName));
            }
            bodyIllegal = false;    // reset: we've left the tag

            // update <choose>-related state
            if (isCoreTag(ns, ln, CHOOSE)) {
                Boolean b = (Boolean) chooseHasWhen.pop();
                if (!b.booleanValue()) {
                    fail(Resources.getMessage("TLV_PARENT_WITHOUT_SUBTAG",
                            CHOOSE, WHEN));
                }
                chooseDepths.pop();
                chooseHasOtherwise.pop();
            }

            // update state related to URL tags
            if (isCoreTag(ns, ln, IMPORT)
                    || isCoreTag(ns, ln, PARAM)
                    || isCoreTag(ns, ln, REDIRECT)
                    || isCoreTag(ns, ln, URL)) {
                urlTags.pop();
            }

            // update our depth
            depth--;
        }

        // are we directly under a <choose>?
	private boolean chooseChild() {
	    return (!chooseDepths.empty()
		&& (depth - 1) == ((Integer) chooseDepths.peek()).intValue());
	}

        private boolean chooseChild() {
            return (!chooseDepths.empty()
                    && (depth - 1) == ((Integer) chooseDepths.peek()).intValue());
        }

    }
}




 * 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.taglibs.standard.tlv;



/**
 * <p>A base class to support SAX-based validation in JSTL.</p>
 *
 * @author Shawn Bayern
 */
public abstract class JstlBaseTLV extends TagLibraryValidator {


    // attributes
    protected static final String VAR = "var";
    protected static final String SCOPE = "scope";

    //scopes
    protected static final String PAGE_SCOPE = "page";
    protected static final String REQUEST_SCOPE = "request";
    protected static final String SESSION_SCOPE = "session";
    protected static final String APPLICATION_SCOPE = "application";

    // Relevant URIs
    protected final String JSP = "http://java.sun.com/JSP/Page";

    // types of sub-classes - used on method validate()
    private static final int TYPE_UNDEFINED = 0;
    protected static final int TYPE_CORE = 1;
    protected static final int TYPE_FMT = 2;
    protected static final int TYPE_SQL = 3;

    //*********************************************************************
    // Validation and configuration state (protected)

    protected String uri;            // our taglib's uri (as passed by JSP container on XML View)
    protected String prefix;            // our taglib's prefix
    protected Vector messageVector;        // temporary error messages
    protected Map config;            // configuration (Map of Sets)
    protected boolean failed;            // have we failed >0 times?
    protected String lastElementId;        // the last element we've seen

    //*********************************************************************
    // Constructor and lifecycle management

    public JstlBaseTLV() {
        super();
        init();
    }

    private void init() {
        messageVector = null;
        prefix = null;
        config = null;
    }

    @Override
    public void release() {
        super.release();
        init();
    }
    


    //*********************************************************************
    // Validation entry point - this method is called by the sub-classes to 
    // do the validation.

    public synchronized ValidationMessage[] validate(
            int type, String prefix, String uri, PageData page) {
        try {
            this.tlvType = type;
            this.uri = uri;
            // initialize
            messageVector = new Vector();

            // save the prefix
            this.prefix = prefix;

            // parse parameters if necessary
            try {
                if (config == null) {
                    configure((String) getInitParameters().get(EXP_ATT_PARAM));
                }
            } catch (NoSuchElementException ex) {
                // parsing error
                return vmFromString(
                        Resources.getMessage("TLV_PARAMETER_ERROR",
                                EXP_ATT_PARAM));
            }

            // get a handler
            DefaultHandler h = getHandler();

            // parse the page
            SAXParserFactory f = SAXParserFactory.newInstance();
            f.setValidating(false);
            f.setNamespaceAware(true);
            SAXParser p = f.newSAXParser();
            p.parse(page.getInputStream(), h);

            if (messageVector.size() == 0) {
                return null;
            } else {
                return vmFromVector(messageVector);
            }

        } catch (SAXException ex) {
            return vmFromString(ex.toString());
        } catch (ParserConfigurationException ex) {
            return vmFromString(ex.toString());
        } catch (IOException ex) {
            return vmFromString(ex.toString());
        }
    }

    //*********************************************************************


    // delegate validation to the appropriate expression language
    // TODO refactor this into EL tag specific functionality

    @Deprecated
    protected String validateExpression(
            String elem, String att, String expr) {

        return null;
    }

    // utility methods to help us match elements in our tagset

    protected boolean isTag(String tagUri,
                            String tagLn,
                            String matchUri,
                            String matchLn) {
        if (tagUri == null
                || tagUri.length() == 0
                || tagLn == null
                || matchUri == null
                || matchLn == null) {
            return false;
        }
        // match beginning of URI since some suffix *_rt tags can
        // be nested in EL enabled tags as defined by the spec
        if (tagUri.length() > matchUri.length()) {

        return isTag(tagUri, tagLn, JSP, target);
    }

    private boolean isTag(int type, String tagUri, String tagLn, String target) {
        return (this.tlvType == type && isTag(tagUri, tagLn, this.uri, target));
    }

    protected boolean isCoreTag(String tagUri, String tagLn, String target) {
        return isTag(TYPE_CORE, tagUri, tagLn, target);
    }

    protected boolean isFmtTag(String tagUri, String tagLn, String target) {
        return isTag(TYPE_FMT, tagUri, tagLn, target);
    }

    protected boolean isSqlTag(String tagUri, String tagLn, String target) {
        return isTag(TYPE_SQL, tagUri, tagLn, target);
    }

    protected boolean isXmlTag(String tagUri, String tagLn, String target) {
        return isTag(TYPE_XML, tagUri, tagLn, target);
    }

    // utility method to determine if an attribute exists

    protected boolean hasAttribute(Attributes a, String att) {
        return (a.getValue(att) != null);
    }

     * method to assist with failure [ as if it's not easy enough
     * already :-) ]
     */

    protected void fail(String message) {
        failed = true;
        messageVector.add(new ValidationMessage(lastElementId, message));
    }

    // returns true if the given attribute name is specified, false otherwise

    protected boolean isSpecified(TagData data, String attributeName) {
        return (data.getAttribute(attributeName) != null);
    }

    // returns true if the 'scope' attribute is valid

    protected boolean hasNoInvalidScope(Attributes a) {
        String scope = a.getValue(SCOPE);

        if ((scope != null)
                && !scope.equals(PAGE_SCOPE)
                && !scope.equals(REQUEST_SCOPE)
                && !scope.equals(SESSION_SCOPE)
                && !scope.equals(APPLICATION_SCOPE)) {
            return false;
        }

        return true;
    }

    // returns true if the 'var' attribute is empty

    protected boolean hasEmptyVar(Attributes a) {
        if ("".equals(a.getValue(VAR))) {
            return true;
        }
        return false;
    }

    // returns true if the 'scope' attribute is present without 'var'

    protected boolean hasDanglingScope(Attributes a) {
        return (a.getValue(SCOPE) != null && a.getValue(VAR) == null);
    }

    // retrieves the local part of a QName

    protected String getLocalPart(String qname) {
        int colon = qname.indexOf(":");
        if (colon == -1) {
            return qname;
        } else {
            return qname.substring(colon + 1);
        }
    }

    //*********************************************************************
    // Miscellaneous utility functions

    // parses our configuration parameter for element:attribute pairs

    private void configure(String info) {
        // construct our configuration map
        config = new HashMap();

        // leave the map empty if we have nothing to configure
        if (info == null) {
            return;
        }

        // separate parameter into space-separated tokens and store them
        StringTokenizer st = new StringTokenizer(info);
        while (st.hasMoreTokens()) {
            String pair = st.nextToken();
            StringTokenizer pairTokens = new StringTokenizer(pair, ":");
            String element = pairTokens.nextToken();
            String attribute = pairTokens.nextToken();
            Object atts = config.get(element);
            if (atts == null) {
                atts = new HashSet();
                config.put(element, atts);
            }
            ((Set) atts).add(attribute);
        }
    }

    // constructs a ValidationMessage[] from a single String and no ID

    static ValidationMessage[] vmFromString(String message) {
        return new ValidationMessage[]{
                new ValidationMessage(null, message)
        };
    }

    // constructs a ValidationMessage[] from a ValidationMessage Vector

    static ValidationMessage[] vmFromVector(Vector v) {
        ValidationMessage[] vm = new ValidationMessage[v.size()];
        for (int i = 0; i < vm.length; i++) {
            vm[i] = (ValidationMessage) v.get(i);
        }
        return vm;
    }
}




 * 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.taglibs.standard.functions;


/**
 * Static functions that extend the Expression Language with standardized behaviour
 * commonly used by page authors.
 * <p/>
 * <strong>Implementation Note:</strong> When passing a String parameter, section
 * 1.18.2 of the EL specification requires the container to coerce a null value to an
 * empty string. These implementation assume such behaviour and do not check for null
 * parameters. Passing a null will generally trigger a NullPointerException.
 *
 * @author Pierre Delisle
 */


    public static String toLowerCase(String input) {
        return input.toLowerCase();
    }

    //*********************************************************************
    // Substring processing

    /**
     * Returns the index (0-based) withing a string of the first occurrence of a specified
     * substring according to the semantics of the method <code>String#indexOf()</code>.
     * <p/>
     * If <code>substring</code> is empty, this matches the beginning of the string and the
     * value returned is 0.
     *
     * @param input     the input string on which the function is applied
     * @param substring the substring to search for in the input string
     * @return the 0-based index of the first matching substring, or -1 if it does not occur
     */

    /**
     * Tests if a string contains the specified substring.
     *
     * @param input     the input string on which the function is applied
     * @param substring the substring tested for
     * @return true if the character sequence represented by the substring
     *         exists in the string
     */
    public static boolean contains(String input, String substring) {
        return input.contains(substring);
    }

    /**
     * Tests if a string contains the specified substring in a case insensitive way.
     * Equivalent to <code>fn:contains(fn:toUpperCase(string), fn:toUpperCase(substring))</code>.
     *
     * @param input     the input string on which the function is applied
     * @param substring the substring tested for
     * @return true if the character sequence represented by the substring
     *         exists in the string
     */
    public static boolean containsIgnoreCase(String input, String substring) {
        return contains(input.toUpperCase(), substring.toUpperCase());

     * Tests if a string starts with the specified prefix according to the semantics
     * of <code>String#startsWith()</code>.
     *
     * @param input  the input string on which the function is applied
     * @param prefix the prefix to be matched
     * @return true if the input string starts with the prefix
     */
    public static boolean startsWith(String input, String prefix) {
        return input.startsWith(prefix);
    }

    /**
     * Tests if a string ends with the specified suffix according to the semantics
     * of <code>String#endsWith()</code>.
     *
     * @param input  the input string on which the function is applied
     * @param suffix the suffix to be matched
     * @return true if the input string ends with the suffix
     */

     * <li>if <code>endIndex < beginIndex</code>, an empty string is returned</li>
     * </ul>
     *
     * @param input      the input string on which the substring function is applied
     * @param beginIndex the beginning index (0-based), inclusive
     * @param endIndex   the end index (0-based), exclusive
     * @return a subset of string
     */
    public static String substring(String input, int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            beginIndex = 0;
        }
        if (endIndex < 0 || endIndex > input.length()) {
            endIndex = input.length();
        }
        if (endIndex < beginIndex) {
            return "";
        }
        return input.substring(beginIndex, endIndex);
    }

    /**
     * Returns a subset of a string following the first occurrence of a specific substring.
     * <p/>
     * If the substring is empty, it matches the beginning of the input string and the
     * entire input string is returned. If the substring does not occur, an empty string is returned.
     *
     * @param input     the input string on which the substring function is applied
     * @param substring the substring that delimits the beginning of the subset
     *                  of the input string to be returned
     * @return a substring of the input string that starts at the first character after the specified substring
     */
    public static String substringAfter(String input, String substring) {

        if (index == -1) {
            return "";
        } else {
            return input.substring(index + substring.length());
        }
    }

    /**
     * Returns a subset of a string immediately before the first occurrence of a specific substring.
     * <p/>
     * If the substring is empty, it matches the beginning of the input string and an empty string is returned.
     * If the substring does not occur, an empty string is returned.
     *
     * @param input     the input string on which the substring function is applied
     * @param substring the substring that delimits the beginning of the subset
     *                  of the input string to be returned
     * @return a substring of the input string that starts at the first character after the specified substring
     */
    public static String substringBefore(String input, String substring) {

        } else {
            return input.substring(0, index);
        }
    }

    //*********************************************************************
    // Character replacement

     * Returns a string resulting from replacing all occurrences of a "before" substring with an "after" substring.
     * The string is processed once and not reprocessed for further replacements.
     *
     * @param input  the string on which the replacement is to be applied
     * @param before the substring to replace
     * @param after  the replacement substring
     * @return a string with before replaced with after
     */
    public static String replace(String input, String before, String after) {
    {
        if (before.length() == 0) {
            return input;
        }

     * If the input string is empty, a single element array containing an empty string is returned.
     * If the delimiters are empty, a single element array containing the input string is returned.
     *
     * @param input      the string to split
     * @param delimiters characters used to split the string
     * @return an array of strings
     */
    public static String[] split(String input, String delimiters) {
    {
        if (input.length() == 0 || delimiters.length() == 0) {
            return new String[]{input};
        }

        StringTokenizer tok = new StringTokenizer(input, delimiters);


    /**
     * Joins all elements of an array into a string.
     * <p/>
     * <strong>Implementation Note</strong>: The specification does not define what happens when
     * elements in the array are null. For compatibility with previous implementations, the string
     * "null" is used although EL conventions would suggest an empty string might be better.
     *
     * @param array     an array of strings to be joined
     * @param separator used to separate the joined strings
     * @return all array elements joined into one string with the specified separator
     */

        if (obj == null) {
            return 0;
        }

        if (obj instanceof String) {
            return ((String) obj).length();
        }

        }
        if (obj instanceof Iterator) {
            int count = 0;
            Iterator iter = (Iterator) obj;
            while (iter.hasNext()) {
                count++;
                iter.next();
            }
            return count;
        }
        if (obj instanceof Enumeration) {
            Enumeration enum_ = (Enumeration) obj;
            int count = 0;
            while (enum_.hasMoreElements()) {
                count++;

            return Array.getLength(obj);
        }
        throw new JspTagException(Resources.getMessage("PARAM_BAD_VALUE"));
    }
}




 * 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.taglibs.standard.tag.rt.sql;

import org.apache.taglibs.standard.tag.common.sql.QueryTagSupport;


    //*********************************************************************
    // Accessor methods

    public void setDataSource(Object dataSource) {
        this.rawDataSource = dataSource;
        this.dataSourceSpecified = true;
    }

    /**

     */
    public void setMaxRows(int maxRows) {
        this.maxRows = maxRows;
        this.maxRowsSpecified = true;
    }

    /**

     * be set using nested value elements.
     */
    public void setSql(String sql) {
        this.sql = sql;
    }

}




 * 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.taglibs.standard.tag.rt.sql;

import javax.servlet.jsp.JspException;

 */
public class TransactionTag extends TransactionTagSupport {
    private String isolationRT;

    //*********************************************************************
    // Accessor methods


     * a String or a DataSource object.
     */
    public void setDataSource(Object dataSource) {
        this.rawDataSource = dataSource;
        this.dataSourceSpecified = true;
    }

    /**

     */
    @Override
    public void setIsolation(String isolation) {
        this.isolationRT = isolation;
    }

    @Override
    public int doStartTag() throws JspException {
        if (isolationRT != null) {
            super.setIsolation(isolationRT);
        }
        return super.doStartTag();
    }
}




 * 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.taglibs.standard.tag.rt.sql;


/**
 * <p>Tag handler for &lt;Driver&gt; in JSTL, used to create
 * a simple DataSource for prototyping.</p>
 * 
 */
public class SetDataSourceTag extends SetDataSourceTagSupport {


    // Accessor methods

    public void setDataSource(Object dataSource) {
        this.dataSource = dataSource;
        this.dataSourceSpecified = true;
    }

    public void setDriver(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public void setUrl(String jdbcURL) {
        this.jdbcURL = jdbcURL;
    }

    public void setUser(String userName) {
        this.userName = userName;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}




 * 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.taglibs.standard.tag.rt.sql;

import java.util.Date;

 * @author Justyna Horwat
 */
public class DateParamTag extends DateParamTagSupport {

    public void setValue(Date value) {
        this.value = value;
    }

    public void setType(String type) {
        this.type = type;
    }
}

Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/rt/sql/ParamTag.java (-3 / +3 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17	package org.apache.taglibs.standard.tag.rt.sql;	17	package org.apache.taglibs.standard.tag.rt.sql;
18		18
19	import org.apache.taglibs.standard.tag.common.sql.ParamTagSupport;	19	import org.apache.taglibs.standard.tag.common.sql.ParamTagSupport;
Lines 24-31 Link Here
24	* @author Hans Bergsten	24	* @author Hans Bergsten
25	*/	25	*/
26	public class ParamTag extends ParamTagSupport {	26	public class ParamTag extends ParamTagSupport {
27		27
28	public void setValue(Object value) {	28	public void setValue(Object value) {
29	this.value = value;	29	this.value = value;
30	}	30	}
31	}	31	}




 * 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.taglibs.standard.tag.rt.sql;

import org.apache.taglibs.standard.tag.common.sql.UpdateTagSupport;

    //*********************************************************************
    // Accessor methods


    /**
     * Setter method for the SQL DataSource. DataSource can be
     * a String or a DataSource object.
     */
    public void setDataSource(Object dataSource) {
        this.rawDataSource = dataSource;
        this.dataSourceSpecified = true;
    }

    /**

     * be set using nested value elements.
     */
    public void setSql(String sql) {
        this.sql = sql;
    }
}




 * 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.taglibs.standard.tag.rt.xml;



    // Deprecated as of JSTL 1.1
    // for tag attribute

    public void setXml(Object xml) throws JspTagException {
        this.xml = xml;
    }

    // 'doc' replaces 'xml' as of JSTL 1.1

    public void setDoc(Object xml) throws JspTagException {
        this.xml = xml;
    }

    public void setSystemId(String systemId) throws JspTagException {
        this.systemId = systemId;
    }

    // for tag attribute

    public void setFilter(XMLFilter filter) throws JspTagException {
        this.filter = filter;
    }

}




 * 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.taglibs.standard.tag.rt.xml;



    // Deprecated as of JSTL 1.1
    // for tag attribute

    public void setXml(Object xml) throws JspTagException {
        setDoc(xml);
    }

    // 'doc' replaces 'xml' as of JSTL 1.1

    public void setDoc(Object xml) throws JspTagException {
        this.xml = xml;
        this.xmlSpecified = true;


    // Deprecated as of JSTL 1.1
    // for tag attribute

    public void setXmlSystemId(String xmlSystemId) throws JspTagException {
        this.xmlSystemId = xmlSystemId;
    }

    // 'docSystemId' replaces 'xmlSystemId' as of JSTL 1.1

    public void setDocSystemId(String xmlSystemId) throws JspTagException {
        this.xmlSystemId = xmlSystemId;
    }

    // for tag attribute

    public void setXslt(Object xslt) throws JspTagException {
        this.xslt = xslt;
    }

    // for tag attribute

    public void setXsltSystemId(String xsltSystemId) throws JspTagException {
        this.xsltSystemId = xsltSystemId;
    }

    // for tag attribute

    public void setResult(Result result) throws JspTagException {
        this.result = result;
    }




 * 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.taglibs.standard.tag.rt.xml;


    // Accessor methods

    // for tag attribute

    public void setEscapeXml(boolean escapeXml) {
        this.escapeXml = escapeXml;
    }

}




 * 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.taglibs.standard.tag.rt.xml;


    // Accessor methods

    // for tag attribute

    public void setName(String name) throws JspTagException {
        this.name = name;
    }

    // for tag attribute

    public void setValue(Object value) throws JspTagException {
        this.value = value;
    }




 * 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.taglibs.standard.tag.rt.fmt;


    // Accessor methods

    // 'value' attribute

    public void setValue(String value) throws JspTagException {
        this.value = value;
        this.valueSpecified = true;
    }

    // 'type' attribute

    public void setType(String type) throws JspTagException {
        this.type = type;
    }

    // 'pattern' attribute

    public void setPattern(String pattern) throws JspTagException {
        this.pattern = pattern;
    }

    // 'parseLocale' attribute

    public void setParseLocale(Object loc) throws JspTagException {
        if (loc != null) {
            if (loc instanceof Locale) {
                this.parseLocale = (Locale) loc;
            } else {
                if (!"".equals((String) loc)) {
                    this.parseLocale = SetLocaleSupport.parseLocale((String)
                            loc);
                }
            }
        }
    }

    // 'integerOnly' attribute

    public void setIntegerOnly(boolean isIntegerOnly) throws JspTagException {
        this.isIntegerOnly = isIntegerOnly;
        this.integerOnlySpecified = true;
    }
}




 * 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.taglibs.standard.tag.rt.fmt;


    // Accessor methods

    // for tag attribute

    public void setKey(String key) throws JspTagException {
        this.keyAttrValue = key;
        this.keySpecified = true;
    }

    // for tag attribute

    public void setBundle(LocalizationContext locCtxt) throws JspTagException {
        this.bundleAttrValue = locCtxt;
        this.bundleSpecified = true;

Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/rt/fmt/SetBundleTag.java (-1 / +2 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17		17
18	package org.apache.taglibs.standard.tag.rt.fmt;	18	package org.apache.taglibs.standard.tag.rt.fmt;
19		19
Lines 34-39 Link Here
34	// Accessor methods	34	// Accessor methods
35		35
36	// for tag attribute	36	// for tag attribute
		37
37	public void setBasename(String basename) throws JspTagException {	38	public void setBasename(String basename) throws JspTagException {
38	this.basename = basename;	39	this.basename = basename;
39	}	40	}




 * 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.taglibs.standard.tag.rt.fmt;


    // Accessor methods

    // 'value' attribute

    public void setValue(Date value) throws JspTagException {
        this.value = value;
    }

    // 'type' attribute

    public void setType(String type) throws JspTagException {
        this.type = type;
    }

    // 'dateStyle' attribute

    public void setDateStyle(String dateStyle) throws JspTagException {
        this.dateStyle = dateStyle;
    }

    // 'timeStyle' attribute

    public void setTimeStyle(String timeStyle) throws JspTagException {
        this.timeStyle = timeStyle;
    }

    // 'pattern' attribute

    public void setPattern(String pattern) throws JspTagException {
        this.pattern = pattern;
    }

    // 'timeZone' attribute

    public void setTimeZone(Object timeZone) throws JspTagException {
        this.timeZone = timeZone;
    }

Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/rt/fmt/SetTimeZoneTag.java (-1 / +2 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17		17
18	package org.apache.taglibs.standard.tag.rt.fmt;	18	package org.apache.taglibs.standard.tag.rt.fmt;
19		19
Lines 34-39 Link Here
34	// Accessor methods	34	// Accessor methods
35		35
36	// for tag attribute	36	// for tag attribute
		37
37	public void setValue(Object value) throws JspTagException {	38	public void setValue(Object value) throws JspTagException {
38	this.value = value;	39	this.value = value;
39	}	40	}




 * 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.taglibs.standard.tag.rt.fmt;


    // Accessor methods

    // 'value' attribute

    public void setValue(String value) throws JspTagException {
        this.value = value;
        this.valueSpecified = true;
    }

    // 'type' attribute

    public void setType(String type) throws JspTagException {
        this.type = type;
    }

    // 'dateStyle' attribute

    public void setDateStyle(String dateStyle) throws JspTagException {
        this.dateStyle = dateStyle;
    }

    // 'timeStyle' attribute

    public void setTimeStyle(String timeStyle) throws JspTagException {
        this.timeStyle = timeStyle;
    }

    // 'pattern' attribute

    public void setPattern(String pattern) throws JspTagException {
        this.pattern = pattern;
    }

    // 'timeZone' attribute

    public void setTimeZone(Object timeZone) throws JspTagException {
        this.timeZone = timeZone;
    }

    // 'parseLocale' attribute

    public void setParseLocale(Object loc) throws JspTagException {
        if (loc != null) {
            if (loc instanceof Locale) {
                this.parseLocale = (Locale) loc;
            } else {
                if (!"".equals((String) loc)) {
                    this.parseLocale = SetLocaleSupport.parseLocale((String)
                            loc);
                }
            }
        }
    }
}




 * 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.taglibs.standard.tag.rt.fmt;


    // Accessor methods

    // for tag attribute

    public void setBasename(String basename) throws JspTagException {
        this.basename = basename;
    }

    // for tag attribute

    public void setPrefix(String prefix) throws JspTagException {
        this.prefix = prefix;
    }

Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/rt/fmt/TimeZoneTag.java (-1 / +2 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17		17
18	package org.apache.taglibs.standard.tag.rt.fmt;	18	package org.apache.taglibs.standard.tag.rt.fmt;
19		19
Lines 34-39 Link Here
34	// Accessor methods	34	// Accessor methods
35		35
36	// for tag attribute	36	// for tag attribute
		37
37	public void setValue(Object value) throws JspTagException {	38	public void setValue(Object value) throws JspTagException {
38	this.value = value;	39	this.value = value;
39	}	40	}




 * 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.taglibs.standard.tag.rt.fmt;


    // Accessor methods

    // for tag attribute

    public void setValue(Object value) throws JspTagException {
        this.value = value;
    }

    // for tag attribute

    public void setVariant(String variant) throws JspTagException {
        this.variant = variant;
    }

Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/rt/fmt/RequestEncodingTag.java (-1 / +2 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17		17
18	package org.apache.taglibs.standard.tag.rt.fmt;	18	package org.apache.taglibs.standard.tag.rt.fmt;
19		19
Lines 34-39 Link Here
34	// Accessor methods	34	// Accessor methods
35		35
36	// for tag attribute	36	// for tag attribute
		37
37	public void setValue(String value) throws JspTagException {	38	public void setValue(String value) throws JspTagException {
38	this.value = value;	39	this.value = value;
39	}	40	}




 * 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.taglibs.standard.tag.rt.fmt;


    // Accessor methods

    // for tag attribute

    public void setValue(Object value) throws JspTagException {
        this.value = value;
        this.valueSpecified = true;
    }
}




 * 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.taglibs.standard.tag.rt.fmt;


    // Accessor methods

    // 'value' attribute

    public void setValue(Object value) throws JspTagException {
        this.value = value;
        this.valueSpecified = true;
    }

    // 'type' attribute

    public void setType(String type) throws JspTagException {
        this.type = type;
    }

    // 'pattern' attribute

    public void setPattern(String pattern) throws JspTagException {
        this.pattern = pattern;
    }

    // 'currencyCode' attribute

    public void setCurrencyCode(String currencyCode) throws JspTagException {
        this.currencyCode = currencyCode;
    }

    // 'currencySymbol' attribute

    public void setCurrencySymbol(String currencySymbol)
            throws JspTagException {
        this.currencySymbol = currencySymbol;
    }

    // 'groupingUsed' attribute

    public void setGroupingUsed(boolean isGroupingUsed)
            throws JspTagException {
        this.isGroupingUsed = isGroupingUsed;
        this.groupingUsedSpecified = true;
    }

    // 'maxIntegerDigits' attribute

    public void setMaxIntegerDigits(int maxDigits) throws JspTagException {
        this.maxIntegerDigits = maxDigits;
        this.maxIntegerDigitsSpecified = true;
    }

    // 'minIntegerDigits' attribute

    public void setMinIntegerDigits(int minDigits) throws JspTagException {
        this.minIntegerDigits = minDigits;
        this.minIntegerDigitsSpecified = true;
    }

    // 'maxFractionDigits' attribute

    public void setMaxFractionDigits(int maxDigits) throws JspTagException {
        this.maxFractionDigits = maxDigits;
        this.maxFractionDigitsSpecified = true;
    }

    // 'minFractionDigits' attribute

    public void setMinFractionDigits(int minDigits) throws JspTagException {
        this.minFractionDigits = minDigits;
        this.minFractionDigitsSpecified = true;
    }
}




 * 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.taglibs.standard.tag.rt.core;


 */

public class ForEachTag
        extends ForEachSupport
        implements LoopTag, IterationTag {
{

    //*********************************************************************
    // Accessor methods

    // for tag attribute

    public void setBegin(int begin) throws JspTagException {
        this.beginSpecified = true;
        this.begin = begin;

    }

    // for tag attribute

    public void setEnd(int end) throws JspTagException {
        this.endSpecified = true;
        this.end = end;

    }

    // for tag attribute

    public void setStep(int step) throws JspTagException {
        this.stepSpecified = true;
        this.step = step;

    }

    public void setItems(Object o) throws JspTagException {
        // for null items, simulate an empty list
        if (o == null) {
            rawItems = new ArrayList();
        } else {
            rawItems = o;
        }
    }
}




 * 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.taglibs.standard.tag.rt.core;


    }

    // for tag attribute

    public void setValue(Object value) {
        this.value = value;
    }

    // for tag attribute

    public void setDefault(String def) {
        this.def = def;
    }

    // for tag attribute

    public void setEscapeXml(boolean escapeXml) {
        this.escapeXml = escapeXml;
    }




 * 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.taglibs.standard.tag.rt.core;


 */

public class ForTokensTag
        extends ForTokensSupport
        implements LoopTag, IterationTag {
{

    //*********************************************************************
    // Accessor methods

    // for tag attribute

    public void setBegin(int begin) throws JspTagException {
        this.beginSpecified = true;
        this.begin = begin;

    }

    // for tag attribute

    public void setEnd(int end) throws JspTagException {
        this.endSpecified = true;
        this.end = end;

    }

    // for tag attribute

    public void setStep(int step) throws JspTagException {
        this.stepSpecified = true;
        this.step = step;

    }

    // stores the 'items' Object we're passed

    public void setItems(Object s) throws JspTagException {
        items = s;
        // use the empty string to indicate "no iteration"
        if (s == null) {
            items = "";
        }
    }

    // stores the 'delims' String we're passed

    public void setDelims(String s) throws JspTagException {
        delims = s;
        // use the empty string to cause monolithic tokenization
        if (s == null) {
            delims = "";
        }
    }

}




 * 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.taglibs.standard.tag.rt.core;


    // Accessor methods

    // for tag attribute

    public void setUrl(String url) throws JspTagException {
        this.url = url;
    }

    // for tag attribute

    public void setContext(String context) throws JspTagException {
        this.context = context;
    }

    // for tag attribute

    public void setCharEncoding(String charEncoding) throws JspTagException {
        this.charEncoding = charEncoding;
    }

Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/rt/core/SetTag.java (-1 / +1 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17		17
18	package org.apache.taglibs.standard.tag.rt.core;	18	package org.apache.taglibs.standard.tag.rt.core;
19		19




 * 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.taglibs.standard.tag.rt.core;


    // Constructor and lifecycle management

    // initialize inherited and local state

    public IfTag() {
        super();
        init();
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();

    // Accessors

    // receives the tag's 'test' attribute

    public void setTest(boolean test) {
        this.test = test;
    }

    // Private utility methods

    // resets internal state

    private void init() {
        test = false;
    }




 * 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.taglibs.standard.tag.rt.core;


    // Accessor methods

    // for tag attribute

    public void setName(String name) throws JspTagException {
        this.name = name;
    }

    // for tag attribute

    public void setValue(String value) throws JspTagException {
        this.value = value;
    }




 * 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.taglibs.standard.tag.rt.core;


    // Accessor methods

    // for tag attribute

    public void setUrl(String url) throws JspTagException {
        this.url = url;
    }

    // for tag attribute

    public void setContext(String context) throws JspTagException {
        this.context = context;
    }




 * 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.taglibs.standard.tag.rt.core;


    // Constructor and lifecycle management

    // initialize inherited and local state

    public WhenTag() {
        super();
        init();
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();

    // Accessors

    // receives the tag's 'test' attribute

    public void setTest(boolean test) {
        this.test = test;
    }

    // Private utility methods

    // resets internal state

    private void init() {
        test = false;
    }




 * 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.taglibs.standard.tag.rt.core;


    // Accessor methods

    // for tag attribute

    public void setValue(String value) throws JspTagException {
        this.value = value;
    }

    // for tag attribute

    public void setContext(String context) throws JspTagException {
        this.context = context;
    }




 * 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.taglibs.standard.tag.common.sql;


/**
 * <p>Tag handler for &lt;SetDataSource&gt; in JSTL, used to create
 * a simple DataSource for prototyping.</p>
 *
 * @author Hans Bergsten
 * @author Justyna Horwat
 */

    // Constructor and initialization

    public SetDataSourceTagSupport() {
        super();
        init();
    }

    private void init() {
        dataSource = null;
        dataSourceSpecified = false;
        jdbcURL = driverClassName = userName = password = null;
        var = null;
        scope = PageContext.PAGE_SCOPE;
    }



    /**
     * Setter method for the scope of the variable to hold the
     * result.
     *
     */
    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }

    public void setVar(String var) {
        this.var = var;
    }



        if (dataSource != null) {
            ds = DataSourceUtil.getDataSource(dataSource, pageContext);
        } else {
            if (dataSourceSpecified) {
                throw new JspException(
                        Resources.getMessage("SQL_DATASOURCE_NULL"));
            }

            DataSourceWrapper dsw = new DataSourceWrapper();
            try {

            }
            catch (Exception e) {
                throw new JspTagException(
                        Resources.getMessage("DRIVER_INVALID_CLASS",
                                e.toString()), e);
            }
            dsw.setJdbcURL(jdbcURL);
            dsw.setUserName(userName);
            dsw.setPassword(password);
            ds = (DataSource) dsw;
        }

        if (var != null) {
            pageContext.setAttribute(var, ds, scope);
        } else {
            Config.set(pageContext, Config.SQL_DATA_SOURCE, ds, scope);
        }

        return SKIP_BODY;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }
}




 * 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.taglibs.standard.tag.common.sql;



/**
 * <p>This class creates a cached version of a <tt>ResultSet</tt>.
 * It's represented as a <tt>Result</tt> implementation, capable of
 * returing an array of <tt>Row</tt> objects containing a <tt>Column</tt>
 * instance for each column in the row.</p>
 * <p/>
 * <p>Note -- this is a private copy for the RI to avoid making the
 * corresponding class in javax.servlet.* public.</p>
 *

     * Build a <code>Result</code> object from a <code>ResultSet</code> object.
     *
     * @param rs an open <tt>ResultSet</tt>, positioned before the first row
     * @throws SQLException if a database error occurs
     */
    public ResultImpl(ResultSet rs) throws SQLException {
        this(rs, -1, -1);

    /**
     * Build a <code>Result</code> object from a <code>ResultSet</code> object.
     *
     * @param rs      an open <tt>ResultSet</tt>, positioned before the first row
     * @param maxRows query maximum rows limit
     * @throws SQLException if a database error occurs
     */
    public ResultImpl(ResultSet rs, int maxRows) throws SQLException {
        // Matching API in ResultSupport - apologies for the bad 

     * This constructor reads the ResultSet and saves a cached
     * copy.
     *
     * @param rs       an open <tt>ResultSet</tt>, positioned before the first
     *                 row
     * @param startRow beginning row to be cached
     * @param maxRows  query maximum rows limit
     * @throws SQLException if a database error occurs
     */
    public ResultImpl(ResultSet rs, int startRow, int maxRows)
            throws SQLException {
    {
        rowMap = new ArrayList();
        rowByIndex = new ArrayList();


        // Create the column name array
        columnNames = new String[noOfColumns];
        for (int i = 1; i <= noOfColumns; i++) {
            columnNames[i - 1] = rsmd.getColumnName(i);
        }

        // Throw away all rows upto startRow

        int processedRows = 0;
        while (rs.next()) {
            if ((maxRows != -1) && (processedRows == maxRows)) {
                isLimited = true;
                break;
            }
            Object[] columns = new Object[noOfColumns];
            SortedMap columnMap =
                    new TreeMap(String.CASE_INSENSITIVE_ORDER);

            // JDBC uses 1 as the lowest index!
            for (int i = 1; i <= noOfColumns; i++) {
                Object value = rs.getObject(i);
                if (rs.wasNull()) {
                    value = null;
                }
                columns[i - 1] = value;
                columnMap.put(columnNames[i - 1], value);
            }
            rowMap.add(columnMap);
            rowByIndex.add(columns);

        }

        //should just be able to return SortedMap[] object
        return (SortedMap[]) rowMap.toArray(new SortedMap[0]);
    }



        }

        //should just be able to return Object[][] object
        return (Object[][]) rowByIndex.toArray(new Object[0][0]);
    }

    /**

     * Returns the number of rows in the cached ResultSet
     *
     * @return the number of cached rows, or -1 if the Result could
     *         not be initialized due to SQLExceptions
     */
    public int getRowCount() {
        if (rowMap == null) {




 * 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.taglibs.standard.tag.common.sql;

import javax.servlet.jsp.JspException;

/**
 * <p>Tag handler for &lt;Param&gt; in JSTL, used to set
 * parameter values for a SQL statement.</p>
 *
 * @author Justyna Horwat
 */



    //*********************************************************************
    // Private constants

    private static final String TIMESTAMP_TYPE = "timestamp";
    private static final String TIME_TYPE = "time";
    private static final String DATE_TYPE = "date";
	


    //*********************************************************************
    // Protected state



    @Override
    public int doEndTag() throws JspException {
        SQLExecutionTag parent = (SQLExecutionTag)
                findAncestorWithClass(this, SQLExecutionTag.class);
        if (parent == null) {
            throw new JspTagException(
                    Resources.getMessage("SQL_PARAM_OUTSIDE_PARENT"));
        }

        if (value != null) {
            convertValue();
        }

        parent.addSQLParameter(value);
        return EVAL_PAGE;
    }




    private void convertValue() throws JspException {

        if ((type == null) || (type.equalsIgnoreCase(TIMESTAMP_TYPE))) {
            if (!(value instanceof java.sql.Timestamp)) {
                value = new java.sql.Timestamp(value.getTime());
            }
        } else if (type.equalsIgnoreCase(TIME_TYPE)) {
            if (!(value instanceof java.sql.Time)) {
                value = new java.sql.Time(value.getTime());
            }
        } else if (type.equalsIgnoreCase(DATE_TYPE)) {
            if (!(value instanceof java.sql.Date)) {
                value = new java.sql.Date(value.getTime());
            }
        } else {
            throw new JspException(
                    Resources.getMessage("SQL_DATE_PARAM_INVALID_TYPE", type));
        }
    }
}




 * 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.taglibs.standard.tag.common.sql;


/**
 * <p>A simple <code>DataSource</code> utility for the standard
 * <code>DriverManager</code> class.
 * <p/>
 * TO DO: need to cache DataSource
 *
 * @author Justyna Horwat
 */
public class DataSourceUtil {

     * is
     */
    static DataSource getDataSource(Object rawDataSource, PageContext pc)
            throws JspException {
        DataSource dataSource = null;
	DataSource dataSource = null;

        if (rawDataSource == null) {
            rawDataSource = Config.find(pc, Config.SQL_DATA_SOURCE);
        }

        if (rawDataSource == null) {
            return null;
        }

        /*
         * If the 'dataSource' attribute's value resolves to a String
         * after rtexpr/EL evaluation, use the string as JNDI path to
         * a DataSource
         */
        if (rawDataSource instanceof String) {
            try {
                Context ctx = new InitialContext();

        } else if (rawDataSource instanceof DataSource) {
            dataSource = (DataSource) rawDataSource;
        } else {
            throw new JspException(
                    Resources.getMessage("SQL_DATASOURCE_INVALID_TYPE"));
        }

        return dataSource;
    }

    /**
     * Parse JDBC parameters and setup dataSource appropriately
     */
    private static DataSource getDataSource(String params)
            throws JspException {
    {
        DataSourceWrapper dataSource = new DataSourceWrapper();

        String[] paramString = new String[4];
        int escCount = 0;
        int aryCount = 0;
        int begin = 0;

        for (int index = 0; index < params.length(); index++) {
            char nextChar = params.charAt(index);
            if (TOKEN.indexOf(nextChar) != -1) {
                if (escCount == 0) {
                    paramString[aryCount] = params.substring(begin, index).trim();
                    begin = index + 1;
                    if (++aryCount > 4) {
                        throw new JspTagException(
                                Resources.getMessage("JDBC_PARAM_COUNT"));
                    }
                }
            }
            if (ESCAPE.indexOf(nextChar) != -1) {
                escCount++;
            } else {
            else {
                escCount = 0;
            }
        }
        paramString[aryCount] = params.substring(begin).trim();

        // use the JDBC URL from the parameter string
        dataSource.setJdbcURL(paramString[0]);

        // try to load a driver if it's present
        if (paramString[1] != null) {
            try {
                dataSource.setDriverClassName(paramString[1]);
            } catch (Exception ex) {
                throw new JspTagException(
                        Resources.getMessage("DRIVER_INVALID_CLASS",
                                ex.toString()), ex);
            }
        }

        // set the username and password
        dataSource.setUserName(paramString[2]);
        dataSource.setPassword(paramString[3]);

        return dataSource;
    }

}




 * 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.taglibs.standard.tag.common.sql;

import javax.servlet.jsp.JspException;

/**
 * <p>Tag handler for &lt;Param&gt; in JSTL, used to set
 * parameter values for a SQL statement.</p>
 *
 * @author Hans Bergsten
 */



    @Override
    public int doEndTag() throws JspException {
        SQLExecutionTag parent = (SQLExecutionTag)
                findAncestorWithClass(this, SQLExecutionTag.class);
        if (parent == null) {
            throw new JspTagException(
                    Resources.getMessage("SQL_PARAM_OUTSIDE_PARENT"));
        }

        Object paramValue = null;
        if (value != null) {
            paramValue = value;
        } else if (bodyContent != null) {
            paramValue = bodyContent.getString().trim();
            if (((String) paramValue).trim().length() == 0) {
                paramValue = null;
            }
        }
	}

        parent.addSQLParameter(paramValue);
        return EVAL_PAGE;
    }
}




 * 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.taglibs.standard.tag.common.sql;


/**
 * <p>A simple <code>DataSource</code> wrapper for the standard
 * <code>DriverManager</code> class.
 *
 * @author Hans Bergsten
 */
public class DataSourceWrapper implements DataSource {

    private String userName;
    private String password;

    public void setDriverClassName(String driverClassName)
            throws ClassNotFoundException, InstantiationException,
            IllegalAccessException {

        //get the classloader

            cl = Thread.currentThread().getContextClassLoader();
        } else {
            cl = java.security.AccessController.doPrivileged(
                    new java.security.PrivilegedAction<ClassLoader>() {
                        public ClassLoader run() {
                            return Thread.currentThread().getContextClassLoader();
                        }
                    });
        }
        //done getting classloader

        Object instance = Class.forName(driverClassName, true, cl).newInstance();
        if (instance instanceof Driver) {
            driver = (Driver) instance;

    }

    public void setJdbcURL(String jdbcURL) {
        this.jdbcURL = jdbcURL;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    /**

        }
        return conn;
    }

    /**
     * Always throws a SQLException. Username and password are set
     * in the constructor and can not be changed.
     */
    public Connection getConnection(String username, String password)
            throws SQLException {
        throw new SQLException(Resources.getMessage("NOT_SUPPORTED"));
    }

    /**
     * Always throws a SQLException. Not supported.
     */
    public int getLoginTimeout() throws SQLException {
        throw new SQLException(Resources.getMessage("NOT_SUPPORTED"));
    }

    /**
     * Always throws a SQLException. Not supported.
     */
    public PrintWriter getLogWriter() throws SQLException {
        throw new SQLException(Resources.getMessage("NOT_SUPPORTED"));
    }

    /**
     * Always throws a SQLException. Not supported.
     */
    public void setLoginTimeout(int seconds) throws SQLException {
        throw new SQLException(Resources.getMessage("NOT_SUPPORTED"));
    }

    /**
     * Always throws a SQLException. Not supported.
     */
    public synchronized void setLogWriter(PrintWriter out) throws SQLException {
        throw new SQLException(Resources.getMessage("NOT_SUPPORTED"));
    }

    public synchronized boolean isWrapperFor(Class c) throws SQLException {
        throw new SQLException(Resources.getMessage("NOT_SUPPORTED"));
    }




 * 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.taglibs.standard.tag.common.sql;


import org.apache.taglibs.standard.tag.common.core.Util;

/**
 * <p>Tag handler for &lt;Update&gt; in JSTL.
 *
 * @author Hans Bergsten
 * @author Justyna Horwat
 */

public abstract class UpdateTagSupport extends BodyTagSupport
        implements TryCatchFinally, SQLExecutionTag {

    private String var;
    private int scope;

    // Constructor and initialization

    public UpdateTagSupport() {
        super();
        init();
    }

    private void init() {
        rawDataSource = null;
        sql = null;
        conn = null;
        parameters = null;
        isPartOfTransaction = dataSourceSpecified = false;
        scope = PageContext.PAGE_SCOPE;
        var = null;
    }



     * result.
     */
    public void setVar(String var) {
        this.var = var;
    }

    /**

    @Override
    public int doStartTag() throws JspException {

        try {
            conn = getConnection();
        } catch (SQLException e) {
            throw new JspException(sql + ": " + e.getMessage(), e);
        }

        return EVAL_BODY_BUFFERED;
    }

    /**

     * named by the <code>var</code> attribute in the scope specified
     * by the <code>scope</code> attribute, as an object that implements
     * the Result interface.
     * <p/>
     * <p>The connection used to execute the statement comes either
     * from the <code>DataSource</code> specified by the
     * <code>dataSource</code> attribute, provided by a parent action

     */
    @Override
    public int doEndTag() throws JspException {
        /*
       * Use the SQL statement specified by the sql attribute, if any,
       * otherwise use the body as the statement.
       */
        String sqlStatement = null;
        if (sql != null) {
            sqlStatement = sql;
        } else if (bodyContent != null) {
            sqlStatement = bodyContent.getString();
        }
        if (sqlStatement == null || sqlStatement.trim().length() == 0) {
            throw new JspTagException(
                    Resources.getMessage("SQL_NO_STATEMENT"));
        }
	}

        int result = 0;
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sqlStatement);
            setParameters(ps, parameters);
            result = ps.executeUpdate();
        }
        catch (Throwable e) {
            throw new JspException(sqlStatement + ": " + e.getMessage(), e);
        } finally {
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException sqe) {
                    throw new JspException(sqe.getMessage(), sqe);
                }
            }
        }
        if (var != null) {
            pageContext.setAttribute(var, new Integer(result), scope);
        }
        return EVAL_PAGE;
    }

    /**
     * Just rethrows the Throwable.
     */
    public void doCatch(Throwable t) throws Throwable {
        throw t;
    }

    /**

     * as part of a transaction.
     */
    public void doFinally() {
        if (conn != null && !isPartOfTransaction) {
            try {
                conn.close();
            } catch (SQLException e) {
                // Not much we can do
            }
        }

        parameters = null;
        conn = null;
    }



     * parameter values.
     */
    public void addSQLParameter(Object o) {
        if (parameters == null) {
            parameters = new ArrayList();
        }
        parameters.add(o);
    }



    // Private utility methods

    private Connection getConnection() throws JspException, SQLException {
        // Fix: Add all other mechanisms
        Connection conn = null;
        isPartOfTransaction = false;

        TransactionTagSupport parent = (TransactionTagSupport)
                findAncestorWithClass(this, TransactionTagSupport.class);
        if (parent != null) {
            if (dataSourceSpecified) {
                throw new JspTagException(
                        Resources.getMessage("ERROR_NESTED_DATASOURCE"));
            }
            conn = parent.getSharedConnection();
            isPartOfTransaction = true;
        } else {
            if ((rawDataSource == null) && dataSourceSpecified) {
                throw new JspException(
                        Resources.getMessage("SQL_DATASOURCE_NULL"));
            }
            DataSource dataSource = DataSourceUtil.getDataSource(rawDataSource,
                    pageContext);
            try {
                conn = dataSource.getConnection();
            } catch (Exception ex) {
                throw new JspException(
                        Resources.getMessage("DATASOURCE_INVALID",
                                ex.toString()));
            }
        }

        return conn;
    }

    private void setParameters(PreparedStatement ps, List parameters)
            throws SQLException {
        if (parameters != null) {
            for (int i = 0; i < parameters.size(); i++) {
	    for (int i = 0; i < parameters.size(); i++) {
                /* The first parameter has index 1.  If a null
                 * is passed to setObject the parameter will be
                 * set to JDBC null so an explicit call to
                 * ps.setNull is not required.
                 */
                ps.setObject(i + 1, parameters.get(i));
            }
        }
    }
}




 * 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.taglibs.standard.tag.common.sql;


import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import java.util.ArrayList;
import java.util.List;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.PageContext;

import javax.servlet.jsp.jstl.core.Config;

import javax.servlet.jsp.jstl.sql.Result;
import javax.servlet.jsp.jstl.sql.SQLExecutionTag;

import javax.servlet.jsp.tagext.BodyTagSupport;
import javax.servlet.jsp.tagext.TryCatchFinally;

import javax.sql.DataSource;

import org.apache.taglibs.standard.resources.Resources;

import org.apache.taglibs.standard.tag.common.core.Util;

/**
 * <p>Tag handler for &lt;Query&gt; in JSTL.
 *
 * @author Hans Bergsten
 * @author Justyna Horwat
 */

public abstract class QueryTagSupport extends BodyTagSupport
        implements TryCatchFinally, SQLExecutionTag {

    private String var;
    private int scope;

                        maxRows = Integer.parseInt((String) obj);
                    } catch (NumberFormatException nfe) {
                        throw new JspException(Resources.getMessage("SQL_MAXROWS_PARSE_ERROR",
                                (String) obj),
                                nfe);
                    }
                } else {
                    throw new JspException(Resources.getMessage("SQL_MAXROWS_INVALID"));

     * named by the <code>var</code> attribute in the scope specified
     * by the <code>scope</code> attribute, as an object that implements
     * the Result interface.
     * <p/>
     * <p>The connection used to execute the statement comes either
     * from the <code>DataSource</code> specified by the
     * <code>dataSource</code> attribute, provided by a parent action

        String sqlStatement = null;
        if (sql != null) {
            sqlStatement = sql;
        } else if (bodyContent != null) {
        else if (bodyContent != null) {
            sqlStatement = bodyContent.getString();
        }
        if (sqlStatement == null || sqlStatement.trim().length() == 0) {

        if (conn != null && !isPartOfTransaction) {
            try {
                conn.close();
            } catch (SQLException e) {
            } // Not much we can do
        }

        conn = null;

        Connection conn = null;
        isPartOfTransaction = false;

        TransactionTagSupport parent = (TransactionTagSupport) findAncestorWithClass(this, TransactionTagSupport.class);
        if (parent != null) {
            if (dataSourceSpecified) {
                throw new JspTagException(Resources.getMessage("ERROR_NESTED_DATASOURCE"));

                throw new JspException(Resources.getMessage("SQL_DATASOURCE_NULL"));
            }
            DataSource dataSource = DataSourceUtil.getDataSource(rawDataSource,
                    pageContext);
            try {
                conn = dataSource.getConnection();
            } catch (Exception ex) {
                throw new JspException(Resources.getMessage("DATASOURCE_INVALID",
                        ex.toString()));
            }
        }

        return conn;
    }

    private void setParameters(PreparedStatement ps, List parameters)
            throws SQLException {
    {
        if (parameters != null) {
            for (int i = 0; i < parameters.size(); i++) {
                /* The first parameter has index 1.  If a null




 * 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.taglibs.standard.tag.common.sql;




/**
 * <p>Tag handler for &lt;Transaction&gt; in JSTL.
 *
 * @author Hans Bergsten
 */

public abstract class TransactionTagSupport extends TagSupport
        implements TryCatchFinally {

    //*********************************************************************
    // Private constants

    private static final String TRANSACTION_READ_COMMITTED
            = "read_committed";
    private static final String TRANSACTION_READ_UNCOMMITTED
            = "read_uncommitted";
    private static final String TRANSACTION_REPEATABLE_READ
            = "repeatable_read";
    private static final String TRANSACTION_SERIALIZABLE
            = "serializable";


    //*********************************************************************

    // Constructor and initialization

    public TransactionTagSupport() {
        super();
        conn = null;
        dataSourceSpecified = false;
        rawDataSource = null;
        isolation = Connection.TRANSACTION_NONE;
    }



    //*********************************************************************
    // Tag logic


    @Override
    public int doStartTag() throws JspException {

        if ((rawDataSource == null) && dataSourceSpecified) {
            throw new JspException(
                    Resources.getMessage("SQL_DATASOURCE_NULL"));
        }

        DataSource dataSource = DataSourceUtil.getDataSource(rawDataSource,
                pageContext);

        try {
            conn = dataSource.getConnection();
            origIsolation = conn.getTransactionIsolation();
            if (origIsolation == Connection.TRANSACTION_NONE) {
                throw new JspTagException(
                        Resources.getMessage("TRANSACTION_NO_SUPPORT"));
            }
            if ((isolation != Connection.TRANSACTION_NONE)
                    && (isolation != origIsolation)) {
                conn.setTransactionIsolation(isolation);
            }
            conn.setAutoCommit(false);
        } catch (SQLException e) {
            throw new JspTagException(
                    Resources.getMessage("ERROR_GET_CONNECTION",
                            e.toString()), e);
        }

        return EVAL_BODY_INCLUDE;
    }

    /**

     */
    @Override
    public int doEndTag() throws JspException {
        try {
            conn.commit();
        } catch (SQLException e) {
            throw new JspTagException(
                    Resources.getMessage("TRANSACTION_COMMIT_ERROR",
                            e.toString()), e);
        }
        return EVAL_PAGE;
    }

    /**
     * Rollbacks the transaction and rethrows the Throwable.
     */
    public void doCatch(Throwable t) throws Throwable {
        if (conn != null) {
            try {
                conn.rollback();
            } catch (SQLException e) {
                // Ignore to not hide orignal exception
            }
        }
        throw t;
    }

    /**

     * closes it.
     */
    public void doFinally() {
        if (conn != null) {
            try {
                if ((isolation != Connection.TRANSACTION_NONE)
                        && (isolation != origIsolation)) {
                    conn.setTransactionIsolation(origIsolation);
                }
                conn.setAutoCommit(true);
                conn.close();
            } catch (SQLException e) {
                // Not much we can do
            }
        }
        conn = null;
        isolation = Connection.TRANSACTION_NONE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        dataSourceSpecified = false;
        rawDataSource = null;
    }



     */
    public void setIsolation(String iso) throws JspTagException {

        if (TRANSACTION_READ_COMMITTED.equals(iso)) {
            isolation = Connection.TRANSACTION_READ_COMMITTED;
        } else if (TRANSACTION_READ_UNCOMMITTED.equals(iso)) {
            isolation = Connection.TRANSACTION_READ_UNCOMMITTED;
        } else if (TRANSACTION_REPEATABLE_READ.equals(iso)) {
            isolation = Connection.TRANSACTION_REPEATABLE_READ;
        } else if (TRANSACTION_SERIALIZABLE.equals(iso)) {
            isolation = Connection.TRANSACTION_SERIALIZABLE;
        } else {
            throw new JspTagException(
                    Resources.getMessage("TRANSACTION_INVALID_ISOLATION"));
        }
    }

    /**

     * the Connection.
     */
    public Connection getSharedConnection() {
        return conn;
    }
}




    /**
     * Create an UnresolvableException object that holds
     * an error message.
     *
     * @param message The error message.
     */
    public UnresolvableException(String message) {
        super(message);
    }

    /**
     * Create an UnresolvableException object that holds
     * an error message, and another exception
     * that caused this exception.
     *
     * @param message The error message.
     * @param e       The exception that caused this exception.
     */
    public UnresolvableException(String message, Exception e) {
        super(message, e);




// would ideally be a base class, but some of our user handlers already
// have their own parents
public class XPathUtil {

    //*********************************************************************
    // Constructor

    /**
     * Constructs a new XPathUtil object associated with the given
     * PageContext.
     */
    public XPathUtil(PageContext pc) {
        pageContext = pc;
    }
    
    int globalVarSize=0;
    public Vector getVariableQNames ( ) {

    int globalVarSize = 0;

    public Vector getVariableQNames() {

        globalVarSize = 0;
        Vector variableVector = new Vector();
        // Now construct attributes in different scopes
        Enumeration enum_ = pageContext.getAttributeNamesInScope(
                PageContext.PAGE_SCOPE);
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(PAGE_NS_URL, PAGE_P, varName);
            //Adding both namespace qualified QName and just localName
            variableVector.addElement(varQName);
            globalVarSize++;

            variableVector.addElement(new QName(null, varName));
            globalVarSize++;
        }
        enum_ = pageContext.getAttributeNamesInScope(
                PageContext.REQUEST_SCOPE);
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(REQUEST_NS_URL, REQUEST_P, varName);
            //Adding both namespace qualified QName and just localName
            variableVector.addElement(varQName);
            globalVarSize++;
            variableVector.addElement(new QName(null, varName));
            globalVarSize++;
        }


            // we may have a page directive preventing session creation/access
            // do not attempt to retrieve attribute names in session scope
            // @see [ http://issues.apache.org/bugzilla/show_bug.cgi?id=35216 ]
            enum_ = pageContext.getAttributeNamesInScope(
                    PageContext.SESSION_SCOPE);
            while (enum_.hasMoreElements()) {
                String varName = (String) enum_.nextElement();
                QName varQName = new QName(SESSION_NS_URL, SESSION_P, varName);
                //Adding both namespace qualified QName and just localName
                variableVector.addElement(varQName);
                globalVarSize++;
                variableVector.addElement(new QName(null, varName));
                globalVarSize++;
            }
        }

        enum_ = pageContext.getAttributeNamesInScope(
                PageContext.APPLICATION_SCOPE);
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(APP_NS_URL, APP_P, varName);
            //Adding both namespace qualified QName and just localName
            variableVector.addElement(varQName);
            globalVarSize++;
            variableVector.addElement(new QName(null, varName));
            globalVarSize++;
        }
        enum_ = pageContext.getRequest().getParameterNames();
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(PARAM_NS_URL, PARAM_P, varName);
            //Adding both namespace qualified QName and just localName
            variableVector.addElement(varQName);
            globalVarSize++;
        }
        enum_ = pageContext.getServletContext().getInitParameterNames();
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(INITPARAM_NS_URL, INITPARAM_P, varName);
            //Adding both namespace qualified QName and just localName
            variableVector.addElement(varQName);
            globalVarSize++;
        }
        enum_ = ((HttpServletRequest) pageContext.getRequest()).getHeaderNames();
        while (enum_.hasMoreElements()) {
            String varName = (String) enum_.nextElement();
            QName varQName = new QName(HEADER_NS_URL, HEADER_P, varName);
            //Adding namespace qualified QName 
            variableVector.addElement(varQName);
            globalVarSize++;
        }
        Cookie[] c = ((HttpServletRequest) pageContext.getRequest()).getCookies();
        if (c != null) {
            for (int i = 0; i < c.length; i++) {
                String varName = c[i].getName();
                QName varQName = new QName(COOKIE_NS_URL, COOKIE_P, varName);
                //Adding namespace qualified QName 
                variableVector.addElement(varQName);
                globalVarSize++;
            }
        }

        return variableVector;

    }

    //*********************************************************************
    // Support for JSTL variable resolution

    // The URLs
    private static final String PAGE_NS_URL
            = "http://java.sun.com/jstl/xpath/page";
    private static final String REQUEST_NS_URL
            = "http://java.sun.com/jstl/xpath/request";
    private static final String SESSION_NS_URL
            = "http://java.sun.com/jstl/xpath/session";
    private static final String APP_NS_URL
            = "http://java.sun.com/jstl/xpath/app";
    private static final String PARAM_NS_URL
            = "http://java.sun.com/jstl/xpath/param";
    private static final String INITPARAM_NS_URL
            = "http://java.sun.com/jstl/xpath/initParam";
    private static final String COOKIE_NS_URL
            = "http://java.sun.com/jstl/xpath/cookie";
    private static final String HEADER_NS_URL
            = "http://java.sun.com/jstl/xpath/header";

    // The prefixes
    private static final String PAGE_P = "pageScope";
    private static final String REQUEST_P = "requestScope";

    private static final String INITPARAM_P = "initParam";
    private static final String COOKIE_P = "cookie";
    private static final String HEADER_P = "header";

    /**
     * org.apache.xpath.VariableStack defines a class to keep track of a stack
     * for template arguments and variables.
     * JstlVariableContext customizes it so it handles JSTL custom
     * variable-mapping rules.
     */
    protected class JstlVariableContext extends org.apache.xpath.VariableStack {

        public JstlVariableContext() {
            super();
        }

        /**
         * Get a variable as an XPath object based on it's qualified name.
         * We override the base class method so JSTL's custom variable-mapping
         * rules can be applied.
         *
         * @param xctxt The XPath context. @@@ we don't use it...
         *              (from xalan: which must be passed in order to lazy evaluate variables.)
         * @param qname The qualified name of the variable.
         */
        @Override
        public XObject getVariableOrParam(
                XPathContext xctxt,
                org.apache.xml.utils.QName qname)
                throws javax.xml.transform.TransformerException, UnresolvableException {
        {
            //p( "***********************************getVariableOrParam begin****");
            String namespace = qname.getNamespaceURI();
            String prefix = qname.getPrefix();
            String localName = qname.getLocalName();

            //p("namespace:prefix:localname=>"+ namespace
            //     + ":" + prefix +":" + localName );

            try {
                Object varObject = getVariableValue(namespace, prefix, localName);


                //XObject varObject = myvs.getVariableOrParam( xpathSupport, varQName);
                XObject newXObject = new XObject(varObject);

                if (Class.forName("org.w3c.dom.Document").isInstance(varObject)) {

                    NodeList nl = ((Document) varObject).getChildNodes();
                    // To allow non-welformed document
                    Vector nodeVector = new Vector();
                    for (int i = 0; i < nl.getLength(); i++) {
                        Node currNode = nl.item(i);
                        if (currNode.getNodeType() == Node.ELEMENT_NODE) {
                            nodeVector.addElement(currNode);
                        }
                    }
                    JSTLNodeList jstlNodeList = new JSTLNodeList(nodeVector);
                    newXObject = new XNodeSetForDOM(jstlNodeList, xctxt);

                    return newXObject;

                }
                if (Class.forName(
                        "org.apache.taglibs.standard.tag.common.xml.JSTLNodeList").isInstance(
                        varObject)) {
                    JSTLNodeList jstlNodeList = (JSTLNodeList) varObject;
                    if ((jstlNodeList.getLength() == 1) &&
                            (!Class.forName("org.w3c.dom.Node").isInstance(jstlNodeList.elementAt(0)))) {
                        varObject = jstlNodeList.elementAt(0);
                        //Now we need to allow this primitive type to be coverted 
                        // to type which Xalan XPath understands 
                    } else {
                        return new XNodeSetForDOM(jstlNodeList, xctxt);
                    }
                }
                if (Class.forName("org.w3c.dom.Node").isInstance(varObject)) {
                    newXObject = new XNodeSetForDOM(new JSTLNodeList((Node) varObject), xctxt);
                } else if (Class.forName("java.lang.String").isInstance(varObject)) {
                    newXObject = new XString((String) varObject);
                } else if (Class.forName("java.lang.Boolean").isInstance(varObject)) {
                    newXObject = new XBoolean((Boolean) varObject);
                } else if (Class.forName("java.lang.Number").isInstance(varObject)) {
                    newXObject = new XNumber((Number) varObject);
                }

                return newXObject;
                // myvs.setGlobalVariable( i, newXObject );
            } catch (ClassNotFoundException cnfe) {
                // This shouldn't happen (TODO: LOG)
                System.out.println("CLASS NOT FOUND EXCEPTION :" + cnfe);
            }
            //System.out.println("*****getVariableOrParam returning *null*" );
            return null;
        }

        /**
         * Retrieve an XPath's variable value using JSTL's custom
         * variable-mapping rules
         */
        public Object getVariableValue(
                String namespace,
                String prefix,
                String localName)
                throws UnresolvableException {
        {
            // p("resolving: ns=" + namespace + " prefix=" + prefix + " localName=" + localName);
            // We can match on namespace with Xalan but leaving as is
            // [ I 'd prefer to match on namespace, but this doesn't appear
            // to work in Jaxen]
            if (prefix == null || prefix.equals("")) {
                return notNull(
                        pageContext.findAttribute(localName),
                        prefix,
                        localName);
            } else if (prefix.equals(PAGE_P)) {
                return notNull(
                        pageContext.getAttribute(localName, PageContext.PAGE_SCOPE),
                        prefix,
                        localName);
            } else if (prefix.equals(REQUEST_P)) {
                return notNull(
                        pageContext.getAttribute(localName,
                                PageContext.REQUEST_SCOPE),
                        prefix,
                        localName);
            } else if (prefix.equals(SESSION_P)) {
                return notNull(
                        pageContext.getAttribute(localName,
                                PageContext.SESSION_SCOPE),
                        prefix,
                        localName);
            } else if (prefix.equals(APP_P)) {
                return notNull(
                        pageContext.getAttribute(localName,
                                PageContext.APPLICATION_SCOPE),
                        prefix,
                        localName);
            } else if (prefix.equals(PARAM_P)) {
                return notNull(
                        pageContext.getRequest().getParameter(localName),
                        prefix,
                        localName);
            } else if (prefix.equals(INITPARAM_P)) {
                return notNull(
                        pageContext.getServletContext().
                                getInitParameter(localName),
                        prefix,
                        localName);
            } else if (prefix.equals(HEADER_P)) {
                HttpServletRequest hsr =
                        (HttpServletRequest) pageContext.getRequest();
                return notNull(
                        hsr.getHeader(localName),
                        prefix,
                        localName);
            } else if (prefix.equals(COOKIE_P)) {
                HttpServletRequest hsr =
                        (HttpServletRequest) pageContext.getRequest();
                Cookie[] c = hsr.getCookies();
                for (int i = 0; i < c.length; i++) {
                    if (c[i].getName().equals(localName)) {
                        return c[i].getValue();
                    }
                }
                throw new UnresolvableException("$" + prefix + ":" + localName);
            } else {
                throw new UnresolvableException("$" + prefix + ":" + localName);
            }
        }

        /**
         * Validate that the Object returned is not null. If it is
         * null, throw an exception.
         */
        private Object notNull(Object o, String prefix, String localName)
                throws UnresolvableException {
            if (o == null) {
                throw new UnresolvableException("$" + (prefix == null ? "" : prefix + ":") + localName);
            }
            //p("resolved to: " + o);
            return o;
        }
    }

    //*********************************************************************
    // Support for XPath evaluation

    private PageContext pageContext;
    private static HashMap exprCache;
    private static JSTLPrefixResolver jstlPrefixResolver = null;

    /**
     * Initialize globally useful data.
     */
    private synchronized static void staticInit() {
        if (jstlPrefixResolver == null) {
            // register supported namespaces

            jstlPrefixResolver.addNamespace("initParam", INITPARAM_NS_URL);
            jstlPrefixResolver.addNamespace("header", HEADER_NS_URL);
            jstlPrefixResolver.addNamespace("cookie", COOKIE_NS_URL);


            // create a HashMap to cache the expressions
            exprCache = new HashMap();
        }
    }

    static DocumentBuilderFactory dbf = null;
    static DocumentBuilder db = null;
    static Document d = null;

    static Document getDummyDocument() {
        try {
            if (dbf == null) {
                dbf = DocumentBuilderFactory.newInstance();
                dbf.setNamespaceAware(true);
                dbf.setValidating(false);
            }
            db = dbf.newDocumentBuilder();

            DOMImplementation dim = db.getDOMImplementation();
            d = dim.createDocument("http://java.sun.com/jstl", "dummyroot", null);
            //d = db.newDocument();
            return d;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    static Document getDummyDocumentWithoutRoot() {
        try {
            if (dbf == null) {
                dbf = DocumentBuilderFactory.newInstance();
                dbf.setNamespaceAware(true);
                dbf.setValidating(false);
            }
            db = dbf.newDocumentBuilder();

            d = db.newDocument();
            return d;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

        doc.appendChild(importedNode);
        return doc;
    }

    // The following variable is used for holding the modified xpath string
    // when adapting parameter for Xalan XPath engine, where we need to have
    // a Non null context node.
    String modifiedXPath = null;
    


    
    
    /**
     * Evaluate an XPath expression to a String value.
     */
    public String valueOf(Node n, String xpath) throws JspTagException {
        //p("******** valueOf(" + n + ", " + xpath + ")");
        staticInit();
        // @@@ but where do we set the Pag4eContext for the varaiblecontext?
        JstlVariableContext vs = new JstlVariableContext();
        XPathContext xpathSupport = new XPathContext();
        xpathSupport.setVarStack(vs);

        Vector varVector = fillVarStack(vs, xpathSupport);

        Node contextNode = adaptParamsForXalan(vs, n, xpath.trim());

        xpath = modifiedXPath;

        //p("******** valueOf: modified xpath: " + xpath);

        XObject result = JSTLXPathAPI.eval(contextNode, xpath,
                jstlPrefixResolver, xpathSupport, varVector);


        //p("******Result TYPE => " + result.getTypeString() );

        String resultString = result.str();
        //p("******** valueOf: after eval: " + resultString);

        return resultString;
    
    }    

    }

    /**
     * Evaluate an XPath expression to a boolean value.
     */
    public boolean booleanValueOf(Node n, String xpath)
            throws JspTagException {

        staticInit();
        JstlVariableContext vs = new JstlVariableContext();
        XPathContext xpathSupport = new XPathContext();
        xpathSupport.setVarStack(vs);

        Vector varVector = fillVarStack(vs, xpathSupport);

        Node contextNode = adaptParamsForXalan(vs, n, xpath.trim());
        xpath = modifiedXPath;

        XObject result = JSTLXPathAPI.eval(contextNode, xpath,
                jstlPrefixResolver, xpathSupport, varVector);

        try {
            return result.bool();
        } catch (TransformerException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ERROR_XOBJECT", ex.toString()), ex);
        }
    }

    /**
     * Evaluate an XPath expression to a List of nodes.
     */
    public List selectNodes(Node n, String xpath) throws JspTagException {

        staticInit();
        JstlVariableContext vs = new JstlVariableContext();
        XPathContext xpathSupport = new XPathContext();
        xpathSupport.setVarStack(vs);
        
        Vector varVector = fillVarStack(vs, xpathSupport);                

        Vector varVector = fillVarStack(vs, xpathSupport);

        Node contextNode = adaptParamsForXalan(vs, n, xpath.trim());
        xpath = modifiedXPath;

        XObject result = JSTLXPathAPI.eval(contextNode, xpath,
                jstlPrefixResolver, xpathSupport, varVector);
        try {
            NodeList nl = JSTLXPathAPI.getNodeList(result);
            return new JSTLNodeList(nl);
        } catch (JspTagException e) {
            try {
                //If result can't be converted to NodeList we receive exception
                // In this case we may have single primitive value as the result
                // Populating List with this value ( String, Boolean or Number )

                //System.out.println("JSTLXPathAPI.getNodeList thrown exception:"+ e);
                Vector vector = new Vector();
                Object resultObject = null;
                if (result.getType() == XObject.CLASS_BOOLEAN) {
                    resultObject = result.bool();
                } else if (result.getType() == XObject.CLASS_NUMBER) {
                    resultObject = result.num();
                } else if (result.getType() == XObject.CLASS_STRING) {
                    resultObject = result.str();
                }

                vector.add(resultObject);
                return new JSTLNodeList(vector);
            } catch (TransformerException te) {
                throw new JspTagException(te.toString(), te);
            }
        }


       
    }

    /**
     * Evaluate an XPath expression to a single node.
     */
    public Node selectSingleNode(Node n, String xpath)
            throws JspTagException {
        //p("selectSingleNode of XPathUtil = passed node:" +
        //   "xpath => " + n + " : " + xpath );

        staticInit();
        JstlVariableContext vs = new JstlVariableContext();
        XPathContext xpathSupport = new XPathContext();
        xpathSupport.setVarStack(vs);
        
        Vector varVector = fillVarStack(vs, xpathSupport);                

        Vector varVector = fillVarStack(vs, xpathSupport);

        Node contextNode = adaptParamsForXalan(vs, n, xpath.trim());
        xpath = modifiedXPath;

        return (Node) JSTLXPathAPI.selectSingleNode(contextNode, xpath,
                jstlPrefixResolver, xpathSupport);
    }

    /**
     * Returns a locally appropriate context given a node.
     */
    private VariableStack getLocalContext() {
        // set up instance-specific contexts
        VariableStack vc = new JstlVariableContext();
        return vc;
    }

    //*********************************************************************
    // Adapt XPath expression for integration with Xalan

    /**
     * To evaluate an XPath expression using Xalan, we need
     * to create an XPath object, which wraps an expression object and provides
     * general services for execution of that expression.
     * <p/>
     * An XPath object can be instantiated with the following information:
     * - XPath expression to evaluate
     * - SourceLocator
     * (reports where an error occurred in the XML source or
     * transformation instructions)
     * - PrefixResolver
     * (resolve prefixes to namespace URIs)
     * - type
     * (one of SELECT or MATCH)
     * - ErrorListener
     * (customized error handling)
     * <p/>
     * Execution of the XPath expression represented by an XPath object
     * is done via method execute which takes the following parameters:
     * - XPathContext
     * The execution context
     * - Node contextNode
     * The node that "." expresses
     * - PrefixResolver namespaceContext
     * The context in which namespaces in the XPath are supposed to be
     * expanded.
     * <p/>
     * Given all of this, if no context node is set for the evaluation
     * of the XPath expression, one must be set so Xalan
     * can successfully evaluate a JSTL XPath expression.
     * (it will not work if the context node is given as a varialbe
     * at the beginning of the expression)
     *
     * @@@ Provide more details...
     */
    protected Node adaptParamsForXalan(JstlVariableContext jvc, Node n,
                                       String xpath) {
        Node boundDocument = null;

        modifiedXPath = xpath;
        String origXPath = xpath;
        boolean whetherOrigXPath = true;

        // If contextNode is not null then  just pass the values to Xalan XPath
        // unless this is an expression that starts off with an xml document 
        if (n != null && !xpath.startsWith("$")) {
            return n;
        }

        if (xpath.startsWith("$")) {
            // JSTL uses $scopePrefix:varLocalName/xpath expression

            String varQName = xpath.substring(xpath.indexOf("$") + 1);
            if (varQName.indexOf("/") > 0) {
                varQName = varQName.substring(0, varQName.indexOf("/"));
            }
            String varPrefix = null;
            String varLocalName = varQName;
            if (varQName.indexOf(":") >= 0) {
                varPrefix = varQName.substring(0, varQName.indexOf(":"));
                varLocalName = varQName.substring(varQName.indexOf(":") + 1);
            }

            if (xpath.indexOf("/") > 0) {
                xpath = xpath.substring(xpath.indexOf("/"));
            } else {
                xpath = "/*";
                whetherOrigXPath = false;
            }


            try {
                Object varObject = jvc.getVariableValue(null, varPrefix,
                        varLocalName);
                //System.out.println( "varObject => : its Class " +varObject +
                // ":" + varObject.getClass() );

                if (Class.forName("org.w3c.dom.Document").isInstance(
                        varObject)) {
                    //boundDocument = ((Document)varObject).getDocumentElement();
                    boundDocument = ((Document) varObject);
                } else {

                    //System.out.println("Creating a Dummy document to pass " +
                    // " onto as context node " );

                    if (Class.forName("org.apache.taglibs.standard.tag.common.xml.JSTLNodeList").isInstance(varObject)) {
                        Document newDocument = getDummyDocument();

                        JSTLNodeList jstlNodeList = (JSTLNodeList) varObject;
                        if (jstlNodeList.getLength() == 1) {
                            if (Class.forName("org.w3c.dom.Node").isInstance(
                                    jstlNodeList.elementAt(0))) {
                                Node node = (Node) jstlNodeList.elementAt(0);
                                boundDocument = getDocumentForNode(node);
                                if (whetherOrigXPath) {
                                    xpath = "/*" + xpath;
                                }

                            } else {


                                //p("String value ( xpathwould be this) => " + xpath);
                                boundDocument = newDocument;
                            }

                        } else {

                            Element dummyroot = newDocument.getDocumentElement();
                            for (int i = 0; i < jstlNodeList.getLength(); i++) {
                                Node currNode = (Node) jstlNodeList.item(i);

                                Node importedNode = newDocument.importNode(
                                        currNode, true);

                                //printDetails ( newDocument);

                                dummyroot.appendChild(importedNode);

                                //p( "Details of the document After importing");
                                //printDetails ( newDocument);

                            // to change the xpath expression.Hopefully this
                            // won't  change the result

                            xpath = "/*" + xpath;
                        }
                    } else if (Class.forName("org.w3c.dom.Node").isInstance(
                            varObject)) {
                        boundDocument = getDocumentForNode((Node) varObject);
                        if (whetherOrigXPath) {
                            xpath = "/*" + xpath;
                        }

                        boundDocument = getDummyDocument();
                        xpath = origXPath;
                    }


                }
            } catch (UnresolvableException ue) {
                // TODO: LOG
                System.out.println("Variable Unresolvable :" + ue.getMessage());
                ue.printStackTrace();
            } catch (ClassNotFoundException cnf) {
                // Will never happen
            }
        } else {
            //System.out.println("Not encountered $ Creating a Dummydocument 2 "+
            //   "pass onto as context node " );
            boundDocument = getDummyDocument();
        }

        modifiedXPath = xpath;
        //System.out.println("Modified XPath::boundDocument =>" + modifiedXPath +
        //    "::" + boundDocument );

        return boundDocument;
    }
    


    //*********************************************************************
    // 

    /**
     * * @@@ why do we have to pass varVector in the varStack first, and then
     * to XPath object?
     */
    private Vector fillVarStack(JstlVariableContext vs, XPathContext xpathSupport)
            throws JspTagException {
        org.apache.xpath.VariableStack myvs = xpathSupport.getVarStack();
        Vector varVector = getVariableQNames();
        for (int i = 0; i < varVector.size(); i++) {
          
            QName varQName = (QName)varVector.elementAt(i);

            QName varQName = (QName) varVector.elementAt(i);

            try {
                XObject variableValue = vs.getVariableOrParam(xpathSupport, varQName);
                //p("&&&&Variable set to => " + variableValue.toString() );
                //p("&&&&Variable type => " + variableValue.getTypeString() );
                myvs.setGlobalVariable(i, variableValue);

            } catch (TransformerException te) {
                throw new JspTagException(te.toString(), te);
            }

        }
        return varVector;
    }


    
    
    
    //*********************************************************************
    // Static support for context retrieval from parent <forEach> tag

    public static Node getContext(Tag t) throws JspTagException {
        ForEachTag xt =
                (ForEachTag) TagSupport.findAncestorWithClass(
                        t, ForEachTag.class);
        if (xt == null) {
            return null;
        } else {
            return (xt.getContext());
        }
    }

    //*********************************************************************
    // Utility methods

    private static void p(String s) {
        System.out.println("[XPathUtil] " + s);
    }

    public static void printDetails(Node n) {
        System.out.println("\n\nDetails of Node = > " + n);
        System.out.println("Name:Type:Node Value = > " + n.getNodeName() +
                ":" + n.getNodeType() + ":" + n.getNodeValue());
        System.out.println("Namespace URI : Prefix : localName = > " +
                n.getNamespaceURI() + ":" + n.getPrefix() + ":" + n.getLocalName());
        System.out.println("\n Node has children => " + n.hasChildNodes());
        if (n.hasChildNodes()) {
            NodeList nl = n.getChildNodes();
            System.out.println("Number of Children => " + nl.getLength());
            for (int i = 0; i < nl.getLength(); i++) {
                Node childNode = nl.item(i);
                printDetails(childNode);
            }
        }
    }
}

class JSTLNodeList extends Vector implements NodeList {

    Vector nodeVector;

    public JSTLNodeList(Vector nodeVector) {
        this.nodeVector = nodeVector;
    }

    public JSTLNodeList(NodeList nl) {
        nodeVector = new Vector();
        //System.out.println("[JSTLNodeList] nodelist details");
        for (int i = 0; i < nl.getLength(); i++) {
            Node currNode = nl.item(i);
            //XPathUtil.printDetails ( currNode );
            nodeVector.add(i, nl.item(i));
        }
    }

    public JSTLNodeList(Node n) {
        nodeVector = new Vector();
        nodeVector.addElement(n);
    }
        


    public Node item(int index) {
        return (Node) nodeVector.elementAt(index);
    }

    @Override
    public Object elementAt(int index) {
        return nodeVector.elementAt(index);
    }

    @Override
    public Object get(int index) {
        return nodeVector.get(index);
    }

    public int getLength() {
        return nodeVector.size();
    }

    @Override
    public int size() {
        //System.out.println("JSTL node list size => " + nodeVector.size() );
        return nodeVector.size();
    }

    // Can implement other Vector methods to redirect those methods to 




 * 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.taglibs.standard.tag.common.xml;


/**
 * <p>Support for the XML library's &lt;forEach&gt; tag.</p>
 *
 * @author Shawn Bayern
 * @see javax.servlet.jsp.jstl.core.LoopTagSupport
 * @author Shawn Bayern
 */
public class ForEachTag extends LoopTagSupport {

    //*********************************************************************
    // Private state

    private String select;                // tag attribute
    private List nodes;                    // XPath result
    private int nodesIndex;                // current index
    private org.w3c.dom.Node current;            // current node

    //*********************************************************************
    // Iteration control methods


    @Override
    protected Object next() throws JspTagException {
        Object o = nodes.get(nodesIndex++);
        if (!(o instanceof org.w3c.dom.Node)) {
            throw new JspTagException(
                    Resources.getMessage("FOREACH_NOT_NODESET"));
        }
        current = (org.w3c.dom.Node) o;
        return current;
    }


    // Tag logic and lifecycle management

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
        super.release();
    }


    // Attribute accessors

    public void setSelect(String select) {
        this.select = select;
    }

    public void setBegin(int begin) throws JspTagException {

        this.step = step;
        validateStep();
    }

    //*********************************************************************
    // Public methods for subtags

    /* Retrieves the current context. */

    public org.w3c.dom.Node getContext() throws JspTagException {
        // expose the current node as the context
        return current;
    }


    // Private utility methods

    private void init() {
        select = null;
        nodes = null;
        nodesIndex = 0;
        current = null;
    }
}





 * 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.taglibs.standard.tag.common.xml;



    protected Object xml;                          // 'xml' attribute
    protected String systemId;                     // 'systemId' attribute
    protected XMLFilter filter;               // 'filter' attribute

    //*********************************************************************
    // Private state

    private String var;                            // 'var' attribute
    private String varDom;               // 'varDom' attribute
    private int scope;                   // processed 'scope' attr
    private int scopeDom;               // processed 'scopeDom' attr

    // state in support of XML parsing...
    private DocumentBuilderFactory dbf;

    // Constructor and initialization

    public ParseSupport() {
        super();
        init();
    }

    private void init() {
        var = varDom = null;
        xml = null;
        systemId = null;
        filter = null;
        dbf = null;
        db = null;
        tf = null;
        th = null;
        scope = PageContext.PAGE_SCOPE;
        scopeDom = PageContext.PAGE_SCOPE;
    }



    // Tag logic

    // parse 'source' or body, storing result in 'var'

    @Override
    public int doEndTag() throws JspException {
        try {
	
	// set up our DocumentBuilder
        if (dbf == null) {
            dbf = DocumentBuilderFactory.newInstance();
            dbf.setNamespaceAware(true);
            dbf.setValidating(false);
        }
        db = dbf.newDocumentBuilder();

            // set up our DocumentBuilder
            if (dbf == null) {
                dbf = DocumentBuilderFactory.newInstance();
                dbf.setNamespaceAware(true);
                dbf.setValidating(false);
            }
            db = dbf.newDocumentBuilder();

            // if we've gotten a filter, set up a transformer to support it
            if (filter != null) {
                if (tf == null) {
                    tf = TransformerFactory.newInstance();
                }
                if (!tf.getFeature(SAXTransformerFactory.FEATURE)) {
                    throw new JspTagException(
                            Resources.getMessage("PARSE_NO_SAXTRANSFORMER"));
                }
                SAXTransformerFactory stf = (SAXTransformerFactory) tf;
                th = stf.newTransformerHandler();
            }

            // produce a Document by parsing whatever the attributes tell us to use
            Document d;
            Object xmlText = this.xml;
            if (xmlText == null) {
                // if the attribute was specified, use the body as 'xml'
                if (bodyContent != null && bodyContent.getString() != null) {
                    xmlText = bodyContent.getString().trim();
                } else {
                    xmlText = "";
                }
            }
            if (xmlText instanceof String) {
                d = parseStringWithFilter((String) xmlText, filter);
            } else if (xmlText instanceof Reader) {
                d = parseReaderWithFilter((Reader) xmlText, filter);
            } else {
                throw new JspTagException(
                        Resources.getMessage("PARSE_INVALID_SOURCE"));
            }
            th = stf.newTransformerHandler();
	}

            // we've got a Document object; store it out as appropriate
            // (let any exclusivity or other constraints be enforced by TEI/TLV)
            if (var != null) {
                pageContext.setAttribute(var, d, scope);
            }
            if (varDom != null) {
                pageContext.setAttribute(varDom, d, scopeDom);
            }
		xmlText = "";
	}
	if (xmlText instanceof String)
	    d = parseStringWithFilter((String) xmlText, filter);
	else if (xmlText instanceof Reader)
	    d = parseReaderWithFilter((Reader) xmlText, filter);
	else
	    throw new JspTagException(
	        Resources.getMessage("PARSE_INVALID_SOURCE"));

            return EVAL_PAGE;
        } catch (SAXException ex) {
            throw new JspException(ex);
        } catch (IOException ex) {
            throw new JspException(ex);
        } catch (ParserConfigurationException ex) {
            throw new JspException(ex);
        } catch (TransformerConfigurationException ex) {
            throw new JspException(ex);
        }
      } catch (IOException ex) {
	throw new JspException(ex);
      } catch (ParserConfigurationException ex) {
	throw new JspException(ex);
      } catch (TransformerConfigurationException ex) {
	throw new JspException(ex);
      }
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }


    //*********************************************************************
    // Private utility methods

    /**
     * Parses the given InputSource after, applying the given XMLFilter.
     */
    private Document parseInputSourceWithFilter(InputSource s, XMLFilter f)
            throws SAXException, IOException {
        if (f != null) {
            // prepare an output Document
            Document o = db.newDocument();

            // use TrAX to adapt SAX events to a Document object
            th.setResult(new DOMResult(o));
            XMLReader xr = XMLReaderFactory.createXMLReader();
            xr.setEntityResolver(new JstlEntityResolver(pageContext));
            //   (note that we overwrite the filter's parent.  this seems
            //    to be expected usage.  we could cache and reset the old
            //    parent, but you can't setParent(null), so this wouldn't

            f.setContentHandler(th);
            f.parse(s);
            return o;
        } else {
            return parseInputSource(s);
        }
    }

    /**
     * Parses the given Reader after applying the given XMLFilter.
     */
    private Document parseReaderWithFilter(Reader r, XMLFilter f)
            throws SAXException, IOException {
        return parseInputSourceWithFilter(new InputSource(r), f);
    }

    /**
     * Parses the given String after applying the given XMLFilter.
     */
    private Document parseStringWithFilter(String s, XMLFilter f)
            throws SAXException, IOException {
        StringReader r = new StringReader(s);
        return parseReaderWithFilter(r, f);
    }

    /**
     * Parses the given Reader after applying the given XMLFilter.
     */
    private Document parseURLWithFilter(String url, XMLFilter f)
            throws SAXException, IOException {
        return parseInputSourceWithFilter(new InputSource(url), f);
    }

    /**
     * Parses the given InputSource into a Document.
     */
    private Document parseInputSource(InputSource s)
            throws SAXException, IOException {
        db.setEntityResolver(new JstlEntityResolver(pageContext));

        // normalize URIs so they can be processed consistently by resolver
        if (systemId == null) {
            s.setSystemId("jstl:");
        } else if (ImportSupport.isAbsoluteUrl(systemId)) {
            s.setSystemId(systemId);
        } else {
            s.setSystemId("jstl:" + systemId);
        }
        return db.parse(s);
    }

    /**
     * Parses the given Reader into a Document.
     */
    private Document parseReader(Reader r) throws SAXException, IOException {
        return parseInputSource(new InputSource(r));
    }

    /**
     * Parses the given String into a Document.
     */
    private Document parseString(String s) throws SAXException, IOException {
        StringReader r = new StringReader(s);
        return parseReader(r);
    }

    /**
     * Parses the URL (passed as a String) into a Document.
     */
    private Document parseURL(String url) throws SAXException, IOException {
        return parseInputSource(new InputSource(url));
    }

    //*********************************************************************
    // JSTL-specific EntityResolver class

    /**
     * Lets us resolve relative external entities.
     */
    public static class JstlEntityResolver implements EntityResolver {
        private final PageContext ctx;

        public JstlEntityResolver(PageContext ctx) {
            this.ctx = ctx;
        }

        public InputSource resolveEntity(String publicId, String systemId)
                throws FileNotFoundException {

            // pass if we don't have a systemId
            if (systemId == null) {
                return null;
            }

            // strip leading "jstl:" off URL if applicable
            if (systemId.startsWith("jstl:")) {
                systemId = systemId.substring(5);
            }

            // we're only concerned with relative URLs
            if (ImportSupport.isAbsoluteUrl(systemId)) {
                return null;
            }

            // for relative URLs, load and wrap the resource.
            // don't bother checking for 'null' since we specifically want
            // the parser to fail if the resource doesn't exist
            InputStream s;
            if (systemId.startsWith("/")) {
                s = ctx.getServletContext().getResourceAsStream(systemId);
                if (s == null) {
                    throw new FileNotFoundException(
                            Resources.getMessage("UNABLE_TO_RESOLVE_ENTITY",
                                    systemId));
                }
            } else {
                String pagePath =
                        ((HttpServletRequest) ctx.getRequest()).getServletPath();
                String basePath =
                        pagePath.substring(0, pagePath.lastIndexOf("/"));
                s = ctx.getServletContext().getResourceAsStream(
                        basePath + "/" + systemId);
                if (s == null) {
                    throw new FileNotFoundException(
                            Resources.getMessage("UNABLE_TO_RESOLVE_ENTITY",
                                    systemId));
                }
            }
            return new InputSource(s);
        }
    }


    // Tag attributes

    public void setVar(String var) {
        this.var = var;
    }

    public void setVarDom(String varDom) {
        this.varDom = varDom;
    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }

    public void setScopeDom(String scopeDom) {
        this.scopeDom = Util.getScope(scopeDom);
    }
}




 * 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.taglibs.standard.tag.common.xml;



    private String select;                    // tag attribute
    private String var;                       // tag attribute
    private int scope;                  // processed tag attribute

    //*********************************************************************
    // Construction and initialization

    }

    // resets local state

    private void init() {
        var = null;
        select = null;
        scope = PageContext.PAGE_SCOPE;
    }


    // Tag logic

    // applies XPath expression from 'select' and stores the result in 'var'

    @Override
    public int doStartTag() throws JspException {
        // process the query
        XPathUtil xu = new XPathUtil(pageContext);
        List result =
                xu.selectNodes(XPathUtil.getContext(this), select);
        Object ret = result;

        // unwrap primitive types if that's what we received
        if (result.size() == 1) {
            Object o = result.get(0);
            if (o instanceof String || o instanceof Boolean
                    || o instanceof Number) {
                ret = o;
            }
        }

        // expose the final result
        pageContext.setAttribute(var, ret, scope);
        return SKIP_BODY;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();

    // Attribute accessors

    public void setSelect(String select) {
        this.select = select;
    }

    public void setVar(String var) {
        this.var = var;
    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }
}




import java.io.StringReader;
import java.io.Writer;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;


            // we can assume at most one of 'var' or 'result' is specified
            if (result != null)
            // we can write directly to the Result
            {
                t.transform(source, result);
            } else if (var != null) {
                // we need a Document
                Document d = db.newDocument();
                Result doc = new DOMResult(d);

     * the current directory in the filesystem.
     */
    private static String wrapSystemId(String systemId) {
        if (systemId == null) {
            return "jstl:";
        } else if (ImportSupport.isAbsoluteUrl(systemId)) {
            return systemId;
        } else {
            return ("jstl:" + systemId);
        }
    }

    /**


    /**
     * Return the Source for a document specified as body content.
     *
     * @return the document Source
     * @throws JspTagException if there is a problem with the body content
     */

                throws TransformerException {

            // pass if we don't have a systemId
            if (href == null) {
                return null;
            }

            // remove "jstl" marker from 'base'
            // NOTE: how 'base' is determined varies among different Xalan


            // we're only concerned with relative URLs
            if (ImportSupport.isAbsoluteUrl(href)
                    || (base != null && ImportSupport.isAbsoluteUrl(base))) {
                return null;
            }

            // base is relative; remove everything after trailing '/'
            if (base == null || base.lastIndexOf("/") == -1) {
                base = "";
            } else {
                base = base.substring(0, base.lastIndexOf("/") + 1);
            }

            // concatenate to produce the real URL we're interested in
            String target = base + href;

            InputStream s;
            if (target.startsWith("/")) {
                s = ctx.getServletContext().getResourceAsStream(target);
                if (s == null) {
                    throw new TransformerException(
                            Resources.getMessage("UNABLE_TO_RESOLVE_ENTITY",
                                    href));
                }
            } else {
                String pagePath =
                        ((HttpServletRequest) ctx.getRequest()).getServletPath();

                        pagePath.substring(0, pagePath.lastIndexOf("/"));
                s = ctx.getServletContext().getResourceAsStream(
                        basePath + "/" + target);
                if (s == null) {
                    throw new TransformerException(
                            Resources.getMessage("UNABLE_TO_RESOLVE_ENTITY",
                                    href));
                }
            }
            return new StreamSource(s);
        }




 * 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.taglibs.standard.tag.common.xml;


    // Constructor and lifecycle management

    // initialize inherited and local state

    public IfTag() {
        super();
        init();
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();

    // Private utility methods

    // resets internal state

    private void init() {
        select = null;
    }




 * 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.taglibs.standard.tag.common.xml;

import org.apache.taglibs.standard.util.EscapeXML;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.TagSupport;

import org.apache.taglibs.standard.util.EscapeXML;

/**
 * <p>Tag handler for &lt;out&gt; in JSTL's XML library.</p>
 * <p/>
 * TODO: should we rename this to OutSupport to match the tag name?
 *
 * @author Shawn Bayern

    // Internal state

    private String select;                       // tag attribute
    protected boolean escapeXml;         // tag attribute

    //*********************************************************************
    // Construction and initialization

    }

    // resets local state

    private void init() {
        select = null;
        escapeXml = true;
    }


    // Tag logic

    // applies XPath expression from 'select' and prints the result

    @Override
    public int doStartTag() throws JspException {
        try {
            XPathUtil xu = new XPathUtil(pageContext);
            String result = xu.valueOf(XPathUtil.getContext(this), select);
            EscapeXML.emit(result, escapeXml, pageContext.getOut());
            return SKIP_BODY;
        } catch (java.io.IOException ex) {
            throw new JspTagException(ex.toString(), ex);
        }
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();

    // Attribute accessors

    public void setSelect(String select) {
        this.select = select;
    }
}




 * created for each evaluation.  A faster way is to precompile the
 * XPaths using the low-level API, and then just use the XPaths
 * over and over.
 * <p/>
 * NOTE: In particular, each call to this method will create a new
 * XPathContext, a new DTMManager... and thus a new DTM. That's very
 * safe, since it guarantees that you're always processing against a

 * methods.
 *
 * @see <a href="http://www.w3.org/TR/xpath">XPath Specification</a>
 * 
 */
public class JSTLXPathAPI extends XPathAPI {
    /**
     * Use an XPath string to select a single node.
     * XPath namespace prefixes are resolved using the prefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return The first node found that matches the XPath, or null.
     *
     * @throws JspTagException
     */
    public static Node selectSingleNode(
            Node contextNode, String str, PrefixResolver prefixResolver)
            throws JspTagException {

        // Have the XObject return its result as a NodeSetDTM.
        NodeIterator nl = selectNodeIterator(contextNode, str, prefixResolver);

        // Return the first node, or null
        return nl.nextNode();
    }

    /**
     * Use an XPath string to select a single node.
     * XPath namespace prefixes are resolved using the prefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return The first node found that matches the XPath, or null.
     *
     * @throws JspTagException
     */
    public static Node selectSingleNode(
            Node contextNode, String str, PrefixResolver prefixResolver,
            XPathContext xpathSupport) throws JspTagException {

        // Have the XObject return its result as a NodeSetDTM.
        NodeIterator nl = selectNodeIterator(contextNode, str, prefixResolver, xpathSupport);

        // Return the first node, or null
        return nl.nextNode();
    }

    /**
     * Use an XPath string to select a nodelist.
     * XPath namespace prefixes are resolved using PrefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return A NodeIterator, should never be null.
     *
     * @throws JspTagException
     */
    public static NodeIterator selectNodeIterator(
            Node contextNode, String str, PrefixResolver prefixResolver)
            throws JspTagException {

        // Execute the XPath, and have it return the result
        XObject list = eval(contextNode, str, prefixResolver, null);

        // Have the XObject return its result as a NodeSetDTM.
        return getNodeIterator(list);
    }

    /**
     * Use an XPath string to select a nodelist.
     * XPath namespace prefixes are resolved using PrefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return A NodeIterator, should never be null.
     *
     * @throws JspTagException
     */
    public static NodeIterator selectNodeIterator(
            Node contextNode, String str, PrefixResolver prefixResolver,
            XPathContext xpathSupport) throws JspTagException {

        // Execute the XPath, and have it return the result
        XObject list = eval(contextNode, str, prefixResolver, xpathSupport);

        // Have the XObject return its result as a NodeSetDTM.
        return getNodeIterator(list);
    }

    /**
     * Use an XPath string to select a nodelist.
     * XPath namespace prefixes are resolved using the prefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return A NodeIterator, should never be null.
     *
     * @throws JspTagException
     */
    private static NodeList selectNodeList(
            Node contextNode, String str, PrefixResolver prefixResolver)
            throws JspTagException {
        // Execute the XPath, and have it return the result
        XObject list = eval(contextNode, str, prefixResolver, null);

        // Return a NodeList.
        return getNodeList(list);
    }

    /**
     * Use an XPath string to select a nodelist.
     * XPath namespace prefixes are resolved using the prefixResolver.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
     * @return A NodeIterator, should never be null.
     *
     * @throws JspTagException
     */
    public static NodeList selectNodeList(
            Node contextNode, String str, PrefixResolver prefixResolver,
            XPathContext xpathSupport)
            throws JspTagException {
    {        
        // Execute the XPath, and have it return the result
        XObject list = eval(contextNode, str, prefixResolver, xpathSupport);

        // Return a NodeList.
        return getNodeList(list);
    }

    /**
     * Returns a NodeIterator from an XObject.
     *
     * @param list The XObject from which a NodeIterator is returned.
     * @return A NodeIterator, should never be null.
     * @throws JspTagException
     */
    private static NodeIterator getNodeIterator(XObject list)
            throws JspTagException {
        try {
            return list.nodeset();
        } catch (TransformerException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ERROR_XOBJECT", ex.toString()), ex);
        }
    }

    /**
     * Returns a NodeList from an XObject.
     *
     * @param list The XObject from which a NodeList is returned.
     * @return A NodeList, should never be null.
     * @throws JspTagException
     */
    static NodeList getNodeList(XObject list)
            throws JspTagException {
        try {
            return list.nodelist();
        } catch (TransformerException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ERROR_XOBJECT", ex.toString()), ex);
        }
    }

    /**
     * Evaluate XPath string to an XObject.
     * XPath namespace prefixes are resolved from the namespaceNode.
     * The implementation of this is a little slow, since it creates
     * a number of objects each time it is called.  This could be optimized
     * to keep the same objects around, but then thread-safety issues would arise.
     *
     * @param contextNode    The node to start searching from.
     * @param str            A valid XPath string.
     * @param xpathSupport   The node from which prefixes in the XPath will be resolved to namespaces.
     * @param prefixResolver Will be called if the parser encounters namespace
     *                       prefixes, to resolve the prefixes to URLs.
     * @return An XObject, which can be used to obtain a string, number, nodelist, etc, should never be null.
     *   @see org.apache.xpath.objects.XObject
     *   @see org.apache.xpath.objects.XNull
     *   @see org.apache.xpath.objects.XBoolean
     *   @see org.apache.xpath.objects.XNumber
     *   @see org.apache.xpath.objects.XString
     *   @see org.apache.xpath.objects.XRTreeFrag
     *
     * @throws JspTagException
     * @see org.apache.xpath.objects.XObject
     * @see org.apache.xpath.objects.XNull
     * @see org.apache.xpath.objects.XBoolean
     * @see org.apache.xpath.objects.XNumber
     * @see org.apache.xpath.objects.XString
     * @see org.apache.xpath.objects.XRTreeFrag
     */
    public static XObject eval(
            Node contextNode, String str, PrefixResolver prefixResolver,
            XPathContext xpathSupport) throws JspTagException {
        //System.out.println("eval of XPathContext params: contextNode:str(xpath)"+
        // ":prefixResolver:xpathSupport => " + contextNode + ":" + str + ":" +
        //  prefixResolver + ":" + xpathSupport );        

            if (xpathSupport == null) {
                return eval(contextNode, str, prefixResolver);
            }

            // Since we don't have a XML Parser involved here, install some default support
            // for things like namespaces, etc.
            // (Changed from: XPathContext xpathSupport = new XPathContext();

            //    XPathContext should be done away with.)
            // Create the XPath object.
            XPath xpath = new XPath(str, null, prefixResolver, XPath.SELECT, null);

            // Execute the XPath, and have it return the result
            int ctxtNode = xpathSupport.getDTMHandleFromNode(contextNode);

            // System.out.println("Context Node id ( after getDTMHandlerFromNode) => " + ctxtNode );
            XObject xobj = xpath.execute(xpathSupport, ctxtNode, prefixResolver);
            return xobj;
        } catch (TransformerException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ERROR_EVALUATING_EXPR", str, ex.toString()), ex);
        } catch (IllegalArgumentException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ILLEGAL_ARG_EVALUATING_EXPR", str, ex.toString()), ex);
        }
    }

    public static XObject eval(
            Node contextNode, String str, PrefixResolver prefixResolver,
            XPathContext xpathSupport, Vector varQNames) throws JspTagException {
        //p("***************** eval ");
        //p( "contextNode => " + contextNode );
        //p( "XPath str => " + str );

        //p( "Var QNames => " + varQNames );
        //p( "Global Var Size => " + varQNames.size() );        
        try {
            XPath xpath = new XPath(str, null, prefixResolver, XPath.SELECT, null);
            xpath.fixupVariables(varQNames, varQNames.size());
            // Execute the XPath, and have it return the result
            int ctxtNode = xpathSupport.getDTMHandleFromNode(contextNode);
            // System.out.println("Context Node id ( after getDTMHandlerFromNode) => " + ctxtNode );            
            return xpath.execute(xpathSupport, ctxtNode, prefixResolver);
        } catch (TransformerException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ERROR_EVALUATING_EXPR", str, ex.toString()), ex);
        } catch (IllegalArgumentException ex) {
            throw new JspTagException(
                    Resources.getMessage("XPATH_ILLEGAL_ARG_EVALUATING_EXPR", str, ex.toString()), ex);
        }
    }

    private static void p(String s) {
        System.out.println("[JSTLXPathAPI] " + s);
    }
}




 * can be used to perform prefix-to-namespace lookup
 * for the XPath object.
 */
public class JSTLPrefixResolver implements PrefixResolver {
{

    /**
     * The context to resolve the prefix from, if the context
     * is not given.
     */

    HashMap namespaces;

    /**
     * The URI for the XML namespace.
     * (Duplicate of that found in org.apache.xpath.XPathContext).
     */
  public static final String S_XMLNAMESPACEURI =
    "http://www.w3.org/XML/1998/namespace";

    public static final String S_XMLNAMESPACEURI =
            "http://www.w3.org/XML/1998/namespace";
   */
  public JSTLPrefixResolver()
  {
    namespaces = new HashMap();
  }

    /**
     * No-arg constructor which would create empty HashMap of namespaces
     */
    public JSTLPrefixResolver() {
        namespaces = new HashMap();
    }

    public JSTLPrefixResolver(HashMap nses) {
        namespaces = nses;
    }
   * context itself.
   * @param prefix Prefix to resolve.
   * @return Namespace that prefix resolves to, or null if prefix
   * is not bound.
   */
  public String getNamespaceForPrefix(String prefix)
  {
    return (String)namespaces.get(prefix);
  }

    /**
     * Given a namespace, get the corresponding prefix.  This assumes that
     * the PrevixResolver hold's it's own namespace context, or is a namespace
     * context itself.
     *
     * @param prefix Prefix to resolve.
     * @return Namespace that prefix resolves to, or null if prefix
     *         is not bound.
     */
    public String getNamespaceForPrefix(String prefix) {
        return (String) namespaces.get(prefix);
    }
  {

    /**
     * Given a prefix and a Context Node, get the corresponding namespace.
     * Warning: This will not work correctly if namespaceContext
     * is an attribute node.
     *
     * @param prefix           Prefix to resolve.
     * @param namespaceContext Node from which to start searching for a
     *                         xmlns attribute that binds a prefix to a namespace.
     * @return Namespace that prefix resolves to, or null if prefix
     *         is not bound.
     */
    public String getNamespaceForPrefix(String prefix,
                                        org.w3c.dom.Node namespaceContext) {

        Node parent = namespaceContext;
        String namespace = null;
      namespace = S_XMLNAMESPACEURI;
    }
    else
    {
      int type;

        if (prefix.equals("xml")) {
            namespace = S_XMLNAMESPACEURI;
        } else {
            int type;
        if (type == Node.ELEMENT_NODE)
        {
          NamedNodeMap nnm = parent.getAttributes();

            while ((null != parent) && (null == namespace)
                    && (((type = parent.getNodeType()) == Node.ELEMENT_NODE)
                    || (type == Node.ENTITY_REFERENCE_NODE))) {
                if (type == Node.ELEMENT_NODE) {
                    NamedNodeMap nnm = parent.getAttributes();

                    for (int i = 0; i < nnm.getLength(); i++) {
                        Node attr = nnm.item(i);
                        String aname = attr.getNodeName();
                        boolean isPrefix = aname.startsWith("xmlns:");

                        if (isPrefix || aname.equals("xmlns")) {
                            int index = aname.indexOf(':');
                            String p = isPrefix ? aname.substring(index + 1) : "";

                            if (p.equals(prefix)) {
                                namespace = attr.getNodeValue();

                                break;
                            }
                        }
                    }
                }

                parent = parent.getParentNode();
            }
          }
        }

        return namespace;
      }
    }

    /**
     * Return the base identifier.
     *
     * @return null
     */
    public String getBaseIdentifier() {
        return null;
    }

    /**
     * @see PrefixResolver#handlesNullPrefixes()
     */
    public boolean handlesNullPrefixes() {
        return false;
    }
  {
    return null;
  }

    public void addNamespace(String prefix, String uri) {
        namespaces.put(prefix, uri);
    }
    return false;
  }

  public void addNamespace ( String prefix, String uri ) {
    namespaces.put( prefix, uri );
  }

}




 * 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.taglibs.standard.tag.common.xml;


 * <p>Support for tag handlers for &lt;param&gt;, the XML parameter
 * subtag for &lt;transformt&lt;.</p>
 *
 * @author Shawn Bayern
 * @see TransformSupport
 * @author Shawn Bayern
 */

public abstract class ParamSupport extends BodyTagSupport {

    // Constructor and initialization

    public ParamSupport() {
        super();
        init();
    }

    private void init() {
        name = null;
        value = null;
    }



    // Tag logic

    // simply send our name and value to our parent <transform> tag

    @Override
    public int doEndTag() throws JspException {
        Tag t = findAncestorWithClass(this, TransformSupport.class);
        if (t == null) {
            throw new JspTagException(
                    Resources.getMessage("PARAM_OUTSIDE_TRANSFORM"));
        }
        TransformSupport parent = (TransformSupport) t;

        Object value = this.value;
        if (value == null) {
            if (bodyContent == null || bodyContent.getString() == null) {
                value = "";
            } else {
                value = bodyContent.getString().trim();
            }
        }
        parent.addParameter(name, value);
        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }
}




 * 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.taglibs.standard.tag.common.xml;


    // Constructor and lifecycle management

    // initialize inherited and local state

    public WhenTag() {
        super();
        init();
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();

    // Private utility methods

    // resets internal state

    private void init() {
        select = null;
    }




 * 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.taglibs.standard.tag.common.fmt;


    //*********************************************************************
    // Private constants

    private static final String NUMBER = "number";
    private static final String CURRENCY = "currency";
    private static final String PERCENT = "percent";


    // Protected state

    protected String value;                      // 'value' attribute
    protected boolean valueSpecified;             // status
    protected String type;                       // 'type' attribute
    protected String pattern;                    // 'pattern' attribute
    protected Locale parseLocale;                // 'parseLocale' attribute

    // Constructor and initialization

    public ParseNumberSupport() {
        super();
        init();
    }

    private void init() {
        value = type = pattern = var = null;
        valueSpecified = false;
        parseLocale = null;
        integerOnlySpecified = false;
        scope = PageContext.PAGE_SCOPE;
    }


    //*********************************************************************
    // Tag attributes known at translation time

    public void setVar(String var) {

    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }




    @Override
    public int doEndTag() throws JspException {
        String input = null;

        // determine the input by...
        if (valueSpecified) {
            // ... reading 'value' attribute
            input = value;
        } else {
            // ... retrieving and trimming our body
            if (bodyContent != null && bodyContent.getString() != null) {
                input = bodyContent.getString().trim();
            }
        }

        if ((input == null) || input.equals("")) {
            if (var != null) {
                pageContext.removeAttribute(var, scope);
            }
            return EVAL_PAGE;
        }

        /*
       * Set up parsing locale: Use locale specified via the 'parseLocale'
       * attribute (if present), or else determine page's locale.
       */
        Locale loc = parseLocale;
        if (loc == null) {
            loc = SetLocaleSupport.getFormattingLocale(
                    pageContext,
                    this,
                    false,
                    NumberFormat.getAvailableLocales());
        }
        if (loc == null) {
            throw new JspException(
                    Resources.getMessage("PARSE_NUMBER_NO_PARSE_LOCALE"));
        }

        // Create parser
        NumberFormat parser = null;
        if ((pattern != null) && !pattern.equals("")) {
            // if 'pattern' is specified, 'type' is ignored
            DecimalFormatSymbols symbols = new DecimalFormatSymbols(loc);
            parser = new DecimalFormat(pattern, symbols);
        } else {
            parser = createParser(loc);
        }

        // Configure parser
        if (integerOnlySpecified) {
            parser.setParseIntegerOnly(isIntegerOnly);
        }

        // Parse number
        Number parsed = null;
        try {
            parsed = parser.parse(input);
        } catch (ParseException pe) {
            throw new JspException(
                    Resources.getMessage("PARSE_NUMBER_PARSE_ERROR", input),
                    pe);
        }

        if (var != null) {
            pageContext.setAttribute(var, parsed, scope);
        } else {
            try {
                pageContext.getOut().print(parsed);
            } catch (IOException ioe) {
                throw new JspTagException(ioe.toString(), ioe);
            }
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }



    // Private utility methods

    private NumberFormat createParser(Locale loc) throws JspException {
        NumberFormat parser = null;

        if ((type == null) || NUMBER.equalsIgnoreCase(type)) {
            parser = NumberFormat.getNumberInstance(loc);
        } else if (CURRENCY.equalsIgnoreCase(type)) {
            parser = NumberFormat.getCurrencyInstance(loc);
        } else if (PERCENT.equalsIgnoreCase(type)) {
            parser = NumberFormat.getPercentInstance(loc);
        } else {
            throw new JspException(
                    Resources.getMessage("PARSE_NUMBER_INVALID_TYPE",
                            type));
        }

        return parser;
    }
}




 * 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.taglibs.standard.tag.common.fmt;


    // Protected state

    protected String keyAttrValue;       // 'key' attribute value
    protected boolean keySpecified;     // 'key' attribute specified
    protected LocalizationContext bundleAttrValue; // 'bundle' attribute value
    protected boolean bundleSpecified;   // 'bundle' attribute specified?


    // Constructor and initialization

    public MessageSupport() {
        super();
        params = new ArrayList();
        init();
    }

    private void init() {
        var = null;
        scope = PageContext.PAGE_SCOPE;
        keyAttrValue = null;
        keySpecified = false;
        bundleAttrValue = null;
        bundleSpecified = false;
    }



    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }



     * @see ParamSupport
     */
    public void addParam(Object arg) {
        params.add(arg);
    }




    @Override
    public int doStartTag() throws JspException {
        params.clear();
        return EVAL_BODY_BUFFERED;
    }

    @Override
    public int doEndTag() throws JspException {

        String key = null;
        LocalizationContext locCtxt = null;

        // determine the message key by...
        if (keySpecified) {
            // ... reading 'key' attribute
            key = keyAttrValue;
        } else {
            // ... retrieving and trimming our body
            if (bodyContent != null && bodyContent.getString() != null) {
                key = bodyContent.getString().trim();
            }
        }

        if ((key == null) || key.equals("")) {
            try {
                pageContext.getOut().print("??????");
            } catch (IOException ioe) {
                throw new JspTagException(ioe.toString(), ioe);
            }
            return EVAL_PAGE;
        }

        String prefix = null;
        if (!bundleSpecified) {
            Tag t = findAncestorWithClass(this, BundleSupport.class);
            if (t != null) {
                // use resource bundle from parent <bundle> tag
                BundleSupport parent = (BundleSupport) t;
                locCtxt = parent.getLocalizationContext();
                prefix = parent.getPrefix();
            } else {
                locCtxt = BundleSupport.getLocalizationContext(pageContext);
            }
        } else {
            // localization context taken from 'bundle' attribute
            locCtxt = bundleAttrValue;
            if (locCtxt.getLocale() != null) {
                SetLocaleSupport.setResponseLocale(pageContext,
                        locCtxt.getLocale());
            }
        }

        String message = UNDEFINED_KEY + key + UNDEFINED_KEY;
        if (locCtxt != null) {
            ResourceBundle bundle = locCtxt.getResourceBundle();
            if (bundle != null) {
                try {
                    // prepend 'prefix' attribute from parent bundle
                    if (prefix != null) {
                        key = prefix + key;
                    }
                    message = bundle.getString(key);
                    // Perform parametric replacement if required
                    if (!params.isEmpty()) {
                        Object[] messageArgs = params.toArray();
                        MessageFormat formatter = new MessageFormat(""); // empty pattern, default Locale
                        if (locCtxt.getLocale() != null) {
                            formatter.setLocale(locCtxt.getLocale());
                        } else {
                            // For consistency with the <fmt:formatXXX> actions,
                            // we try to get a locale that matches the user's preferences
                            // as well as the locales supported by 'date' and 'number'.

                                formatter.setLocale(locale);
                            }
                        }
                        formatter.applyPattern(message);
                        message = formatter.format(messageArgs);
                    }
                } catch (MissingResourceException mre) {
                    message = UNDEFINED_KEY + key + UNDEFINED_KEY;
                }
            }
        }

        if (var != null) {
            pageContext.setAttribute(var, message, scope);
        } else {
            try {
                pageContext.getOut().print(message);
            } catch (IOException ioe) {
                throw new JspTagException(ioe.toString(), ioe);
            }
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }
}




 * 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.taglibs.standard.tag.common.fmt;



public abstract class SetBundleSupport extends TagSupport {


    //*********************************************************************
    // Protected state


    // Constructor and initialization

    public SetBundleSupport() {
        super();
        init();
    }

    private void init() {
        basename = null;
        scope = PageContext.PAGE_SCOPE;
    }



    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }




    @Override
    public int doEndTag() throws JspException {
        LocalizationContext locCtxt =
                BundleSupport.getLocalizationContext(pageContext, basename);

        if (var != null) {
            pageContext.setAttribute(var, locCtxt, scope);
        } else {
            Config.set(pageContext, Config.FMT_LOCALIZATION_CONTEXT, locCtxt,
                    scope);
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }
}




 * 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.taglibs.standard.tag.common.fmt;

import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;

    //*********************************************************************
    // Private constants

    /**
     * Name of configuration setting for maximum number of entries in the
     * cached dateformat map
     */
    private static final String DATE_CACHE_PARAM =
            "org.apache.taglibs.standard.tag.common.fmt.dateFormatCacheSize";

    private static final String DATE = "date";
    private static final String TIME = "time";


    private static Map dateFormatCache = null;

    /**
     * Default maximum  cache size
     */
    private static final int MAX_SIZE = 100;


    //*********************************************************************

    // Constructor and initialization

    public FormatDateSupport() {
        super();
        init();
    }

    private void init() {
        type = dateStyle = timeStyle = null;
        pattern = var = null;
        value = null;
        timeZone = null;
        scope = PageContext.PAGE_SCOPE;
    }


    //*********************************************************************
    // Tag attributes known at translation time

    public void setVar(String var) {

    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }



    /*
     * Formats the given date and time.
     */

    @Override
    public int doEndTag() throws JspException {

        String formatted = null;

        if (value == null) {
            if (var != null) {
                pageContext.removeAttribute(var, scope);
            }
            return EVAL_PAGE;
        }

        // Create formatter
        Locale locale = SetLocaleSupport.getFormattingLocale(
                pageContext,
                this,
                true,
                DateFormat.getAvailableLocales());

        if (locale != null) {
            DateFormat formatter = createFormatter(locale, pattern);

            // Set time zone
            TimeZone tz = null;
            if ((timeZone instanceof String)
                    && ((String) timeZone).equals("")) {
                timeZone = null;
            }
            if (timeZone != null) {
                if (timeZone instanceof String) {
                    tz = TimeZone.getTimeZone((String) timeZone);
                } else if (timeZone instanceof TimeZone) {
                    tz = (TimeZone) timeZone;
                } else {
                    throw new JspTagException(
                            Resources.getMessage("FORMAT_DATE_BAD_TIMEZONE"));
                }
            } else {
                tz = TimeZoneSupport.getTimeZone(pageContext, this);
            }
            if (tz != null) {
                formatter.setTimeZone(tz);
            }
            formatted = formatter.format(value);
        } else {
            // no formatting locale available, use Date.toString()
            formatted = value.toString();
        }

        if (var != null) {
            pageContext.setAttribute(var, formatted, scope);
        } else {
            try {
                pageContext.getOut().print(formatted);
            } catch (IOException ioe) {
                throw new JspTagException(ioe.toString(), ioe);
            }
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }



    // Private utility methods

    private DateFormat createFormatter(Locale loc, String pattern) throws JspException {
        DateFormat formatter = null;

        // lazy initialization of cache
        if (dateFormatCache == null) {
            String value = pageContext.getServletContext().getInitParameter(DATE_CACHE_PARAM);
            final int maxSize = (value != null) ? Integer.parseInt(value) : MAX_SIZE;
            dateFormatCache = Collections.synchronizedMap(new LinkedHashMap() {
                @Override
                protected boolean removeEldestEntry(Map.Entry eldest) {
                    return size() > maxSize;
                }
            });
        }

        // Apply pattern, if present
        if (pattern != null) {
            if ((type == null) || DATE.equalsIgnoreCase(type)) {
                String key = DATE + pattern + loc;
                formatter = (DateFormat) dateFormatCache.get(key);
                if (formatter == null) {
                    formatter = new SimpleDateFormat(pattern, loc);
                    dateFormatCache.put(key, formatter);
                }
            } else if (TIME.equalsIgnoreCase(type)) {
                String key = TIME + pattern + loc;
                formatter = (DateFormat) dateFormatCache.get(key);
                if (formatter == null) {
                    formatter = new SimpleDateFormat(pattern, loc);
                    dateFormatCache.put(key, formatter);
                }
            } else if (DATETIME.equalsIgnoreCase(type)) {
                String key = DATETIME + pattern + loc;
                formatter = (DateFormat) dateFormatCache.get(key);
                if (formatter == null) {
                    formatter = new SimpleDateFormat(pattern, loc);
                    dateFormatCache.put(key, formatter);
                }
            } else {
                throw new JspException(
                        Resources.getMessage("FORMAT_DATE_INVALID_TYPE",
                                type));
            }
            return formatter;
        }

        if ((type == null) || DATE.equalsIgnoreCase(type)) {
            int style = Util.getStyle(dateStyle, "FORMAT_DATE_INVALID_DATE_STYLE");
            String key = DATE + style + loc;
		    String key = DATE + pattern + loc;
            formatter = (DateFormat) dateFormatCache.get(key);
            if (formatter == null) {
                formatter = DateFormat.getDateInstance(style, loc);
                dateFormatCache.put(key, formatter);
            }
        } else if (TIME.equalsIgnoreCase(type)) {
            int style = Util.getStyle(timeStyle, "FORMAT_DATE_INVALID_TIME_STYLE");
            String key = TIME + style + loc;
            formatter = (DateFormat) dateFormatCache.get(key);
            if (formatter == null) {
                formatter = DateFormat.getTimeInstance(style, loc);
                dateFormatCache.put(key, formatter);
            }
        } else if (DATETIME.equalsIgnoreCase(type)) {
            int style1 = Util.getStyle(dateStyle, "FORMAT_DATE_INVALID_DATE_STYLE");
            int style2 = Util.getStyle(timeStyle, "FORMAT_DATE_INVALID_TIME_STYLE");
            String key = DATETIME + style1 + loc + style2;
            formatter = (DateFormat) dateFormatCache.get(key);
            if (formatter == null) {
                formatter = DateFormat.getDateTimeInstance(style1, style2, loc);
                dateFormatCache.put(key, formatter);
            }
        } else {
            throw new JspException(
                    Resources.getMessage("FORMAT_DATE_INVALID_TYPE",
                            type));
        }

        return formatter;
	}

	if ((type == null) || DATE.equalsIgnoreCase(type)) {
		int style = Util.getStyle(dateStyle, "FORMAT_DATE_INVALID_DATE_STYLE");
		String key = DATE + style + loc;
		formatter = (DateFormat) dateFormatCache.get(key);
		if(formatter == null) {
			formatter = DateFormat.getDateInstance(style, loc);
			dateFormatCache.put(key, formatter);
		}
	} else if (TIME.equalsIgnoreCase(type)) {
		int style = Util.getStyle(timeStyle, "FORMAT_DATE_INVALID_TIME_STYLE");
		String key = TIME + style + loc;
		formatter = (DateFormat) dateFormatCache.get(key);
		if(formatter == null) {
			formatter = DateFormat.getTimeInstance(style, loc);
			dateFormatCache.put(key, formatter);
		}
	} else if (DATETIME.equalsIgnoreCase(type)) {
		int style1 = Util.getStyle(dateStyle, "FORMAT_DATE_INVALID_DATE_STYLE");
		int style2 = Util.getStyle(timeStyle, "FORMAT_DATE_INVALID_TIME_STYLE");
		String key = DATETIME + style1 + loc + style2;
		formatter = (DateFormat) dateFormatCache.get(key);
		if(formatter == null) {
			formatter = DateFormat.getDateTimeInstance(style1, style2, loc);
			dateFormatCache.put(key, formatter);
		}
	} else {
	    throw new JspException(
                    Resources.getMessage("FORMAT_DATE_INVALID_TYPE", 
					 type));
	}

	return formatter;
    }
}




 * 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.taglibs.standard.tag.common.fmt;



public abstract class SetTimeZoneSupport extends TagSupport {


    //*********************************************************************
    // Protected state


    // Constructor and initialization

    public SetTimeZoneSupport() {
        super();
        init();
    }

    // resets local state

    private void init() {
        value = var = null;
        scope = PageContext.PAGE_SCOPE;
    }


    //*********************************************************************
    // Tag attributes known at translation time

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }

    public void setVar(String var) {


    @Override
    public int doEndTag() throws JspException {
        TimeZone timeZone = null;

        if (value == null) {
            timeZone = TimeZone.getTimeZone("GMT");
        } else if (value instanceof String) {
            if (((String) value).trim().equals("")) {
                timeZone = TimeZone.getTimeZone("GMT");
            } else {
                timeZone = TimeZone.getTimeZone((String) value);
            }
        } else {
            timeZone = (TimeZone) value;
        }

        if (var != null) {
            pageContext.setAttribute(var, timeZone, scope);
        } else {
            Config.set(pageContext, Config.FMT_TIME_ZONE, timeZone, scope);
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }
}




 * 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.taglibs.standard.tag.common.fmt;


    // Protected state

    protected String value;                      // 'value' attribute
    protected boolean valueSpecified;             // status
    protected String type;                       // 'type' attribute
    protected String pattern;                    // 'pattern' attribute
    protected Object timeZone;                   // 'timeZone' attribute

    // Constructor and initialization

    public ParseDateSupport() {
        super();
        init();
    }

    private void init() {
        type = dateStyle = timeStyle = null;
        value = pattern = var = null;
        valueSpecified = false;
        timeZone = null;
        scope = PageContext.PAGE_SCOPE;
        parseLocale = null;
    }


    //*********************************************************************
    // Tag attributes known at translation time

    public void setVar(String var) {

    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }




        // determine the input by...
        if (valueSpecified) {
            // ... reading 'value' attribute
            input = value;
        } else {
            // ... retrieving and trimming our body
            if (bodyContent != null && bodyContent.getString() != null) {
                input = bodyContent.getString().trim();
            }
        }

        if ((input == null) || input.equals("")) {
            if (var != null) {
                pageContext.removeAttribute(var, scope);
            }
            return EVAL_PAGE;
        }

        /*
       * Set up parsing locale: Use locale specified via the 'parseLocale'
       * attribute (if present), or else determine page's locale.
       */
        Locale locale = parseLocale;
        if (locale == null) {
            locale = SetLocaleSupport.getFormattingLocale(
                    pageContext,
                    this,
                    false,
                    DateFormat.getAvailableLocales());
        }
        if (locale == null) {
            throw new JspException(
                    Resources.getMessage("PARSE_DATE_NO_PARSE_LOCALE"));
        }

        // Create parser
        DateFormat parser = createParser(locale);

        // Apply pattern, if present
        if (pattern != null) {
            try {
                ((SimpleDateFormat) parser).applyPattern(pattern);
            } catch (ClassCastException cce) {
                parser = new SimpleDateFormat(pattern, locale);
            }
        }

        // Set time zone
        TimeZone tz = null;
        if ((timeZone instanceof String) && ((String) timeZone).equals("")) {
            timeZone = null;
        }
        if (timeZone != null) {
            if (timeZone instanceof String) {
                tz = TimeZone.getTimeZone((String) timeZone);
            } else if (timeZone instanceof TimeZone) {
                tz = (TimeZone) timeZone;
            } else {
                throw new JspException(
                        Resources.getMessage("PARSE_DATE_BAD_TIMEZONE"));
            }
        } else {
            tz = TimeZoneSupport.getTimeZone(pageContext, this);
        }
        if (tz != null) {
            parser.setTimeZone(tz);
        }

        // Parse date
        Date parsed = null;
        try {
            parsed = parser.parse(input);
        } catch (ParseException pe) {
            throw new JspException(
                    Resources.getMessage("PARSE_DATE_PARSE_ERROR", input),
                    pe);
        }

        if (var != null) {
            pageContext.setAttribute(var, parsed, scope);
        } else {
            try {
                pageContext.getOut().print(parsed);
            } catch (IOException ioe) {
                throw new JspTagException(ioe.toString(), ioe);
            }
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }



    // Private utility methods

    private DateFormat createParser(Locale loc) throws JspException {
        DateFormat parser = null;

        if ((type == null) || DATE.equalsIgnoreCase(type)) {
            parser = DateFormat.getDateInstance(
                    Util.getStyle(dateStyle, "PARSE_DATE_INVALID_DATE_STYLE"),
                    loc);
        } else if (TIME.equalsIgnoreCase(type)) {
            parser = DateFormat.getTimeInstance(
                    Util.getStyle(timeStyle, "PARSE_DATE_INVALID_TIME_STYLE"),
                    loc);
        } else if (DATETIME.equalsIgnoreCase(type)) {
            parser = DateFormat.getDateTimeInstance(
                    Util.getStyle(dateStyle, "PARSE_DATE_INVALID_DATE_STYLE"),
                    Util.getStyle(timeStyle, "PARSE_DATE_INVALID_TIME_STYLE"),
                    loc);
        } else {
            throw new JspException(
                    Resources.getMessage("PARSE_DATE_INVALID_TYPE", type));
        }

        parser.setLenient(false);

        return parser;
    }
}




 * 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.taglibs.standard.tag.common.fmt;


 */

public abstract class BundleSupport extends BodyTagSupport {
    


    //*********************************************************************
    // Private constants


    // Constructor and initialization

    public BundleSupport() {
        super();
        init();
    }

    private void init() {
        basename = prefix = null;
        locCtxt = null;
    }


    //*********************************************************************
    // Collaboration with subtags

    public LocalizationContext getLocalizationContext() {
        return locCtxt;
    }

    public String getPrefix() {
        return prefix;
    }




    @Override
    public int doStartTag() throws JspException {
        locCtxt = getLocalizationContext(pageContext, basename);
        return EVAL_BODY_BUFFERED;
    }

    @Override
    public int doEndTag() throws JspException {
        if (bodyContent != null) {
            try {
                pageContext.getOut().print(bodyContent.getString());
            } catch (IOException ioe) {
                throw new JspTagException(ioe.toString(), ioe);
            }
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();
        init();
    }



     * Gets the default I18N localization context.
     *
     * @param pc Page in which to look up the default I18N localization context
     */
    public static LocalizationContext getLocalizationContext(PageContext pc) {
        LocalizationContext locCtxt = null;

        Object obj = Config.find(pc, Config.FMT_LOCALIZATION_CONTEXT);
        if (obj == null) {
            return null;
        }

        if (obj instanceof LocalizationContext) {
            locCtxt = (LocalizationContext) obj;
        } else {
            // localization context is a bundle basename
            locCtxt = getLocalizationContext(pc, (String) obj);
        }

        return locCtxt;
    }

    /**
     * Gets the resource bundle with the given base name, whose locale is
     * determined as follows:
     * <p/>
     * Check if a match exists between the ordered set of preferred
     * locales and the available locales, for the given base name.
     * The set of preferred locales consists of a single locale
     * (if the <tt>javax.servlet.jsp.jstl.fmt.locale</tt> configuration
     * setting is present) or is equal to the client's preferred locales
     * determined from the client's browser settings.
     * <p/>
     * <p> If no match was found in the previous step, check if a match
     * exists between the fallback locale (given by the
     * <tt>javax.servlet.jsp.jstl.fmt.fallbackLocale</tt> configuration
     * setting) and the available locales, for the given base name.
     *
     * @param pc       Page in which the resource bundle with the
     *                 given base name is requested
     * @param basename Resource bundle base name
     *
     * @return Localization context containing the resource bundle with the
     *         given base name and the locale that led to the resource bundle match,
     *         or the empty localization context if no resource bundle match was found
     */
    public static LocalizationContext getLocalizationContext(PageContext pc,
                                                             String basename) {
        LocalizationContext locCtxt = null;
        ResourceBundle bundle = null;

        if ((basename == null) || basename.equals("")) {
            return new LocalizationContext();
        }

        // Try preferred locales
        Locale pref = SetLocaleSupport.getLocale(pc, Config.FMT_LOCALE);
        if (pref != null) {
            // Preferred locale is application-based
            bundle = findMatch(basename, pref);
            if (bundle != null) {
                locCtxt = new LocalizationContext(bundle, pref);
            }
        } else {
            // Preferred locales are browser-based
            locCtxt = findMatch(pc, basename);
        }
	
	if (locCtxt == null) {
	    // No match found with preferred locales, try using fallback locale
	    pref = SetLocaleSupport.getLocale(pc, Config.FMT_FALLBACK_LOCALE);
	    if (pref != null) {
		bundle = findMatch(basename, pref);
		if (bundle != null) {
		    locCtxt = new LocalizationContext(bundle, pref);
		}
	    }
	}

        if (locCtxt == null) {
            // No match found with preferred locales, try using fallback locale
            pref = SetLocaleSupport.getLocale(pc, Config.FMT_FALLBACK_LOCALE);
            if (pref != null) {
                bundle = findMatch(basename, pref);
                if (bundle != null) {
                    locCtxt = new LocalizationContext(bundle, pref);
                }
            }
        }
	    }
	}
		 
	if (locCtxt != null) {
	    // set response locale
	    if (locCtxt.getLocale() != null) {
		SetLocaleSupport.setResponseLocale(pc, locCtxt.getLocale());
	    }
	} else {
	    // create empty localization context
	    locCtxt = new LocalizationContext();
	}

        if (locCtxt == null) {
            // try using the root resource bundle with the given basename
            try {
                ClassLoader cl = getClassLoaderCheckingPrivilege();
                bundle = ResourceBundle.getBundle(basename, EMPTY_LOCALE, cl);
                if (bundle != null) {
                    locCtxt = new LocalizationContext(bundle, null);
                }
            } catch (MissingResourceException mre) {
                // do nothing
            }
        }

        if (locCtxt != null) {
            // set response locale
            if (locCtxt.getLocale() != null) {
                SetLocaleSupport.setResponseLocale(pc, locCtxt.getLocale());
            }
        } else {
            // create empty localization context
            locCtxt = new LocalizationContext();
        }

        return locCtxt;
    }


    //*********************************************************************
    // Private utility methods

    /*
    * Determines the client's preferred locales from the request, and compares
    * each of the locales (in order of preference) against the available
    * locales in order to determine the best matching locale.
    *
    * @param pageContext the page in which the resource bundle with the
    * given base name is requested
    * @param basename the resource bundle's base name
    *
    * @return the localization context containing the resource bundle with
    * the given base name and best matching locale, or <tt>null</tt> if no
    * resource bundle match was found
    */

    private static LocalizationContext findMatch(PageContext pageContext,
                                                 String basename) {
        LocalizationContext locCtxt = null;

        // Determine locale from client's browser settings.

        for (Enumeration enum_ = Util.getRequestLocales((HttpServletRequest) pageContext.getRequest());
             enum_.hasMoreElements();) {
            Locale pref = (Locale) enum_.nextElement();
            ResourceBundle match = findMatch(basename, pref);
            if (match != null) {
                locCtxt = new LocalizationContext(match, pref);
                break;
            }
        }

        return locCtxt;
    }

    /*

     * language-match between the preferred locale and the locale of
     * the bundle returned by java.util.ResourceBundle.getBundle().
     */

    private static ResourceBundle findMatch(String basename, Locale pref) {
        ResourceBundle match = null;

        try {
            ClassLoader cl = getClassLoaderCheckingPrivilege();
            ResourceBundle bundle = ResourceBundle.getBundle(basename, pref, cl);
            Locale avail = bundle.getLocale();
            if (pref.equals(avail)) {
                // Exact match
                match = bundle;
            } else {
                /*
                 * We have to make sure that the match we got is for
                 * the specified locale. The way ResourceBundle.getBundle()

                 *     - avail locale must be equal to preferred locale
                 *     - avail country must be empty or equal to preferred country
                 *       (the equality match might have failed on the variant)
                 */
                if (pref.getLanguage().equals(avail.getLanguage())
                        && ("".equals(avail.getCountry()) || pref.getCountry().equals(avail.getCountry()))) {
                    /*
                  * Language match.
                  * By making sure the available locale does not have a
                  * country and matches the preferred locale's language, we
                  * rule out "matches" based on the container's default
                  * locale. For example, if the preferred locale is
                  * "en-US", the container's default locale is "en-UK", and
                  * there is a resource bundle (with the requested base
                  * name) available for "en-UK", ResourceBundle.getBundle()
                  * will return it, but even though its language matches
                  * that of the preferred locale, we must ignore it,
                  * because matches based on the container's default locale
                  * are not portable across different containers with
                  * different default locales.
                  */
                    match = bundle;
                }
            }
        } catch (MissingResourceException mre) {
        }

        return match;
    }

    private static ClassLoader getClassLoaderCheckingPrivilege() {
        ClassLoader cl;
        SecurityManager sm = System.getSecurityManager();

            cl = Thread.currentThread().getContextClassLoader();
        } else {
            cl = java.security.AccessController.doPrivileged(
                    new java.security.PrivilegedAction<ClassLoader>() {
                        public ClassLoader run() {
                            return Thread.currentThread().getContextClassLoader();
                        }
                    });
        }
        return cl;
    }




 * 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.taglibs.standard.tag.common.fmt;


    // Protected state

    protected Object value;                      // 'value' attribute
  


    //*********************************************************************
    // Private state


    // Constructor and initialization

    public TimeZoneSupport() {
        super();
        init();
    }

    private void init() {
        value = null;
    }



    // Collaboration with subtags

    public TimeZone getTimeZone() {
        return timeZone;
    }



    @Override
    public int doStartTag() throws JspException {

        if (value == null) {
            timeZone = TimeZone.getTimeZone("GMT");
        } else if (value instanceof String) {
            if (((String) value).trim().equals("")) {
                timeZone = TimeZone.getTimeZone("GMT");
            } else {
                timeZone = TimeZone.getTimeZone((String) value);
            }
        } else {
            timeZone = (TimeZone) value;
        }

        return EVAL_BODY_BUFFERED;
    }

    @Override
    public int doEndTag() throws JspException {
        try {
            pageContext.getOut().print(bodyContent.getString());
        } catch (IOException ioe) {
            throw new JspTagException(ioe.toString(), ioe);
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }



     * nested inside a &lt;timeZone&gt; action and no time zone configuration
     * setting exists
     */

    static TimeZone getTimeZone(PageContext pc, Tag fromTag) {
        TimeZone tz = null;

        Tag t = findAncestorWithClass(fromTag, TimeZoneSupport.class);
        if (t != null) {
            // use time zone from parent <timeZone> tag
            TimeZoneSupport parent = (TimeZoneSupport) t;
            tz = parent.getTimeZone();
        } else {
            // get time zone from configuration setting
            Object obj = Config.find(pc, Config.FMT_TIME_ZONE);
            if (obj != null) {
                if (obj instanceof TimeZone) {
                    tz = (TimeZone) obj;
                } else {
                    tz = TimeZone.getTimeZone((String) obj);
                }
            }
        }

        return tz;
    }
}




 * 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.taglibs.standard.tag.common.fmt;



public abstract class SetLocaleSupport extends TagSupport {


    //*********************************************************************
    // Private constants


    // Constructor and initialization

    public SetLocaleSupport() {
        super();
        init();
    }

    private void init() {
        value = variant = null;
        scope = PageContext.PAGE_SCOPE;
    }


    //*********************************************************************
    // Tag attributes known at translation time

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }




    @Override
    public int doEndTag() throws JspException {
        Locale locale = null;

        if (value == null) {
            locale = Locale.getDefault();
        } else if (value instanceof String) {
            if (((String) value).trim().equals("")) {
                locale = Locale.getDefault();
            } else {
                locale = parseLocale((String) value, variant);
            }
        } else {
            locale = (Locale) value;
        }

        Config.set(pageContext, Config.FMT_LOCALE, locale, scope);
        setResponseLocale(pageContext, locale);

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }



     * See parseLocale(String, String) for details.
     */
    public static Locale parseLocale(String locale) {
        return parseLocale(locale, null);
    }

    /**
     * Parses the given locale string into its language and (optionally)
     * country components, and returns the corresponding
     * <tt>java.util.Locale</tt> object.
     * <p/>
     * If the given locale string is null or empty, the runtime's default
     * locale is returned.
     *
     * @param locale  the locale string to parse
     * @param variant the variant
     *
     * @return <tt>java.util.Locale</tt> object corresponding to the given
     *         locale string, or the runtime's default locale if the locale string is
     *         null or empty
     *
     * @throws IllegalArgumentException if the given locale does not have a
     *                                  language component or has an empty country component
     */
    public static Locale parseLocale(String locale, String variant) {

        Locale ret = null;
        String language = locale;
        String country = null;
        int index = -1;

        if (((index = locale.indexOf(HYPHEN)) > -1)
                || ((index = locale.indexOf(UNDERSCORE)) > -1)) {
            language = locale.substring(0, index);
            country = locale.substring(index + 1);
        }

        if ((language == null) || (language.length() == 0)) {
            throw new IllegalArgumentException(
                    Resources.getMessage("LOCALE_NO_LANGUAGE"));
        }

        if (country == null) {
            if (variant != null) {
                ret = new Locale(language, "", variant);
            } else {
                ret = new Locale(language, "");
            }
        } else if (country.length() > 0) {
            if (variant != null) {
                ret = new Locale(language, country, variant);
            } else {
                ret = new Locale(language, country);
            }
        } else {
            throw new IllegalArgumentException(
                    Resources.getMessage("LOCALE_EMPTY_COUNTRY"));
        }

        return ret;
    }



     * the given locale
     * @param locale the response locale
     */

    static void setResponseLocale(PageContext pc, Locale locale) {
        // set response locale
        ServletResponse response = pc.getResponse();
        response.setLocale(locale);

        // get response character encoding and store it in session attribute
        if (pc.getSession() != null) {
            try {
                pc.setAttribute(RequestEncodingSupport.REQUEST_CHAR_SET,
                        response.getCharacterEncoding(),
                        PageContext.SESSION_SCOPE);
            } catch (IllegalStateException ex) {
            } // invalidated session ignored
        }
    }

    /*
    * Returns the formatting locale to use with the given formatting action
    * in the given page.
    *
    * @param pc The page context containing the formatting action
    * @param fromTag The formatting action
    * @param format <tt>true</tt> if the formatting action is of type
    * <formatXXX> (as opposed to <parseXXX>), and <tt>false</tt> otherwise
    * (if set to <tt>true</tt>, the formatting locale that is returned by
    * this method is used to set the response locale).
    *
    * @param avail the array of available locales
    *
    * @return the formatting locale to use
    */

    static Locale getFormattingLocale(PageContext pc,
                                      Tag fromTag,
                                      boolean format,
                                      Locale[] avail) {

        LocalizationContext locCtxt = null;
	
	// Get formatting locale from enclosing <fmt:bundle>
	Tag parent = findAncestorWithClass(fromTag, BundleSupport.class);
	if (parent != null) {
	    /*
	     * use locale from localization context established by parent
	     * <fmt:bundle> action, unless that locale is null
	     */
	    locCtxt = ((BundleSupport) parent).getLocalizationContext();
	    if (locCtxt.getLocale() != null) {
		if (format) {
		    setResponseLocale(pc, locCtxt.getLocale());
		}
		return locCtxt.getLocale();
	    }
	}

        // Get formatting locale from enclosing <fmt:bundle>
        Tag parent = findAncestorWithClass(fromTag, BundleSupport.class);
        if (parent != null) {
            /*
            * use locale from localization context established by parent
            * <fmt:bundle> action, unless that locale is null
            */
            locCtxt = ((BundleSupport) parent).getLocalizationContext();
            if (locCtxt.getLocale() != null) {
                if (format) {
                    setResponseLocale(pc, locCtxt.getLocale());
                }
                return locCtxt.getLocale();
            }
        }

        // Use locale from default I18N localization context, unless it is null
        if ((locCtxt = BundleSupport.getLocalizationContext(pc)) != null) {
            if (locCtxt.getLocale() != null) {
                if (format) {
                    setResponseLocale(pc, locCtxt.getLocale());
                }
                return locCtxt.getLocale();
            }
        }
	    match = findFormattingMatch(pref, avail);
	} else {
	    // Preferred locales are browser-based 
	    match = findFormattingMatch(pc, avail);
	}
	if (match == null) {
	    //Use fallback locale.
	    pref = getLocale(pc, Config.FMT_FALLBACK_LOCALE);
	    if (pref != null) {
		match = findFormattingMatch(pref, avail);
	    }
	}
 	if (format && (match != null)) {
	    setResponseLocale(pc, match);
	}

        /*
       * Establish formatting locale by comparing the preferred locales
       * (in order of preference) against the available formatting
       * locales, and determining the best matching locale.
       */
        Locale match = null;
        Locale pref = getLocale(pc, Config.FMT_LOCALE);
        if (pref != null) {
            // Preferred locale is application-based
            match = findFormattingMatch(pref, avail);
        } else {
            // Preferred locales are browser-based
            match = findFormattingMatch(pc, avail);
        }
        if (match == null) {
            //Use fallback locale.
            pref = getLocale(pc, Config.FMT_FALLBACK_LOCALE);
            if (pref != null) {
                match = findFormattingMatch(pref, avail);
            }
        }
        if (format && (match != null)) {
            setResponseLocale(pc, match);
        }

        return match;
    }

    /**

     * by getFormattingLocale(PageContext).
     */
    static Locale[] availableFormattingLocales;

    static {
        Locale[] dateLocales = DateFormat.getAvailableLocales();
        Locale[] numberLocales = NumberFormat.getAvailableLocales();
        Vector vec = new Vector(dateLocales.length);
        for (int i = 0; i < dateLocales.length; i++) {
            for (int j = 0; j < numberLocales.length; j++) {
                if (dateLocales[i].equals(numberLocales[j])) {
                    vec.add(dateLocales[i]);
                    break;

            }
        }
        availableFormattingLocales = new Locale[vec.size()];
        availableFormattingLocales = (Locale[]) vec.toArray(availableFormattingLocales);
        /*
        for (int i=0; i<availableFormattingLocales.length; i++) {
            System.out.println("AvailableLocale[" + i + "] " + availableFormattingLocales[i]);
        }
        */
    }

    /*
    * Returns the formatting locale to use when <fmt:message> is used
    * with a locale-less localization context.
    *
    * @param pc The page context containing the formatting action
    * @return the formatting locale to use
    */

    static Locale getFormattingLocale(PageContext pc) {
        /*
       * Establish formatting locale by comparing the preferred locales
       * (in order of preference) against the available formatting
       * locales, and determining the best matching locale.
       */
        Locale match = null;
        Locale pref = getLocale(pc, Config.FMT_LOCALE);
        if (pref != null) {
            // Preferred locale is application-based
            match = findFormattingMatch(pref, availableFormattingLocales);
        } else {
            // Preferred locales are browser-based
            match = findFormattingMatch(pc, availableFormattingLocales);
        }
        if (match == null) {
            //Use fallback locale.
            pref = getLocale(pc, Config.FMT_FALLBACK_LOCALE);
            if (pref != null) {
                match = findFormattingMatch(pref, availableFormattingLocales);
            }
        }
        if (match != null) {
            setResponseLocale(pc, match);
        }

        return match;
    }

    /*

     * configuration parameter, or <tt>null</tt> if no scoped attribute or
     * configuration parameter with the given name exists
     */

    static Locale getLocale(PageContext pageContext, String name) {
        Locale loc = null;

        Object obj = Config.find(pageContext, name);
        if (obj != null) {
            if (obj instanceof Locale) {
                loc = (Locale) obj;
            } else {
                loc = parseLocale((String) obj);
            }
        }

        return loc;
    }



     *
     * @return Best matching locale, or <tt>null</tt> if no match was found
     */

    private static Locale findFormattingMatch(PageContext pageContext,
                                              Locale[] avail) {
        Locale match = null;
        for (Enumeration enum_ = Util.getRequestLocales((HttpServletRequest) pageContext.getRequest());
             enum_.hasMoreElements();) {
            Locale locale = (Locale) enum_.nextElement();
            match = findFormattingMatch(locale, avail);
            if (match != null) {
                break;
            }
        }

        return match;
    }

    /*

     * @return Available locale that best matches the given preferred locale,
     * or <tt>null</tt> if no match exists
     */

    private static Locale findFormattingMatch(Locale pref, Locale[] avail) {
        Locale match = null;
        boolean langAndCountryMatch = false;
        for (int i = 0; i < avail.length; i++) {
            if (pref.equals(avail[i])) {
                // Exact match
                match = avail[i];
                break;
            } else if (
                    !"".equals(pref.getVariant()) &&
                            "".equals(avail[i].getVariant()) &&
                            pref.getLanguage().equals(avail[i].getLanguage()) &&
                            pref.getCountry().equals(avail[i].getCountry())) {
                // Language and country match; different variant
                match = avail[i];
                langAndCountryMatch = true;
            } else if (
                    !langAndCountryMatch &&
                            pref.getLanguage().equals(avail[i].getLanguage()) &&
                            ("".equals(avail[i].getCountry()))) {
                // Language match
                if (match == null) {
                    match = avail[i];
                }
            }
        }
        return match;
    }
}




 * 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.taglibs.standard.tag.common.fmt;


    // Package-scoped constants

    static final String REQUEST_CHAR_SET =
            "javax.servlet.jsp.jstl.fmt.request.charset";


    //*********************************************************************

    // Tag attributes

    protected String value;             // 'value' attribute
    


    //*********************************************************************
    // Derived information

    protected String charEncoding;   // derived from 'value' attribute  
    


    //*********************************************************************
    // Constructor and initialization

    public RequestEncodingSupport() {
        super();
        init();
    }

    private void init() {
        value = null;
    }



    @Override
    public int doEndTag() throws JspException {
        charEncoding = value;
        if ((charEncoding == null)
                && (pageContext.getRequest().getCharacterEncoding() == null)) {
            // Use charset from session-scoped attribute
            charEncoding = (String)
                    pageContext.getAttribute(REQUEST_CHAR_SET,
                            PageContext.SESSION_SCOPE);
            if (charEncoding == null) {
                // Use default encoding
                charEncoding = DEFAULT_ENCODING;
            }
        }

        /*
       * If char encoding was already set in the request, we don't need to
       * set it again.
       */
        if (charEncoding != null) {
            try {
                pageContext.getRequest().setCharacterEncoding(charEncoding);
            } catch (UnsupportedEncodingException uee) {
                throw new JspTagException(uee.toString(), uee);
            }
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }
}




 * 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.taglibs.standard.tag.common.fmt;


 * subtag in JSTL 1.0 which supplies an argument for parametric replacement
 * to its parent &lt;message&gt; tag.
 *
 * @author Jan Luehe
 * @see MessageSupport
 * @author Jan Luehe
 */

public abstract class ParamSupport extends BodyTagSupport {

    // Protected state

    protected Object value;                          // 'value' attribute
    protected boolean valueSpecified;                 // status


    //*********************************************************************
    // Constructor and initialization

    public ParamSupport() {
        super();
        init();
    }

    private void init() {
        value = null;
        valueSpecified = false;
    }



    // Tag logic

    // Supply our value to our parent <fmt:message> tag

    @Override
    public int doEndTag() throws JspException {
        Tag t = findAncestorWithClass(this, MessageSupport.class);
        if (t == null) {
            throw new JspTagException(Resources.getMessage(
                    "PARAM_OUTSIDE_MESSAGE"));
        }
        MessageSupport parent = (MessageSupport) t;

        /*
       * Get argument from 'value' attribute or body, as appropriate, and
       * add it to enclosing <fmt:message> tag, even if it is null or equal
       * to "".
       */
        Object input = null;
        // determine the input by...
        if (valueSpecified) {
            // ... reading 'value' attribute
            input = value;
        } else {
            // ... retrieving and trimming our body (TLV has ensured that it's
            // non-empty)
            input = bodyContent.getString().trim();
        }
        parent.addParam(input);

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }
}




 * 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.taglibs.standard.tag.common.fmt;


    // Private constants

    private static final Class[] GET_INSTANCE_PARAM_TYPES =
            new Class[]{String.class};
    private static final String NUMBER = "number";
    private static final String CURRENCY = "currency";
    private static final String PERCENT = "percent";


    // Protected state

    protected Object value;                    // 'value' attribute
    protected boolean valueSpecified;           // status
    protected String type;                     // 'type' attribute
    protected String pattern;                  // 'pattern' attribute
    protected String currencyCode;             // 'currencyCode' attribute

    // Constructor and initialization

    static {
        try {
            currencyClass = Class.forName("java.util.Currency");
            // container's runtime is J2SE 1.4 or greater
        } catch (Exception cnfe) {
        }
    }

    public FormatNumberSupport() {
        super();
        init();
    }

    private void init() {
        value = type = null;
        valueSpecified = false;
        pattern = var = currencyCode = currencySymbol = null;
        groupingUsedSpecified = false;
        maxIntegerDigitsSpecified = minIntegerDigitsSpecified = false;
        maxFractionDigitsSpecified = minFractionDigitsSpecified = false;
        scope = PageContext.PAGE_SCOPE;
    }


    //*********************************************************************
    // Tag attributes known at translation time

    public void setVar(String var) {

    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }




    @Override
    public int doEndTag() throws JspException {
        String formatted = null;
        Object input = null;

        // determine the input by...
        if (valueSpecified) {
            // ... reading 'value' attribute
            input = value;
        } else {
            // ... retrieving and trimming our body
            if (bodyContent != null && bodyContent.getString() != null) {
                input = bodyContent.getString().trim();
            }
        }

        if ((input == null) || input.equals("")) {
            // Spec says:
            // If value is null or empty, remove the scoped variable 
            // if it is specified (see attributes var and scope).
            if (var != null) {
                pageContext.removeAttribute(var, scope);
            }
            return EVAL_PAGE;
        }

        /*
       * If 'value' is a String, it is first parsed into an instance of
       * java.lang.Number
       */
        if (input instanceof String) {
            try {
                if (((String) input).indexOf('.') != -1) {
                    input = Double.valueOf((String) input);
                } else {
                    input = Long.valueOf((String) input);
                }
            } catch (NumberFormatException nfe) {
                throw new JspException(
                        Resources.getMessage("FORMAT_NUMBER_PARSE_ERROR", input),
                        nfe);
            }
        }

        // Determine formatting locale
        Locale loc = SetLocaleSupport.getFormattingLocale(
                pageContext,
                this,
                true,
                NumberFormat.getAvailableLocales());

        if (loc != null) {
            // Create formatter
            NumberFormat formatter = null;
            if ((pattern != null) && !pattern.equals("")) {
                // if 'pattern' is specified, 'type' is ignored
                DecimalFormatSymbols symbols = new DecimalFormatSymbols(loc);
                formatter = new DecimalFormat(pattern, symbols);
            } else {
                formatter = createFormatter(loc);
            }
            if (((pattern != null) && !pattern.equals(""))
                    || CURRENCY.equalsIgnoreCase(type)) {
                try {
                    setCurrency(formatter);
                } catch (Exception e) {
                    throw new JspException(
                            Resources.getMessage("FORMAT_NUMBER_CURRENCY_ERROR"),
                            e);
                }
            }
            configureFormatter(formatter);
            formatted = formatter.format(input);
        } else {
            // no formatting locale available, use toString()
            formatted = input.toString();
        }

        if (var != null) {
            pageContext.setAttribute(var, formatted, scope);
        } else {
            try {
                pageContext.getOut().print(formatted);
            } catch (IOException ioe) {
                throw new JspTagException(ioe.toString(), ioe);
            }
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }



    // Private utility methods

    private NumberFormat createFormatter(Locale loc) throws JspException {
        NumberFormat formatter = null;

        if ((type == null) || NUMBER.equalsIgnoreCase(type)) {
            formatter = NumberFormat.getNumberInstance(loc);
        } else if (CURRENCY.equalsIgnoreCase(type)) {
            formatter = NumberFormat.getCurrencyInstance(loc);
        } else if (PERCENT.equalsIgnoreCase(type)) {
            formatter = NumberFormat.getPercentInstance(loc);
        } else {
            throw new JspException(
                    Resources.getMessage("FORMAT_NUMBER_INVALID_TYPE", type));
        }

        return formatter;
    }

    /*

     * 'maxFractionDigits', and 'minFractionDigits' attributes to the given
     * formatter.
     */

    private void configureFormatter(NumberFormat formatter) {
        if (groupingUsedSpecified) {
            formatter.setGroupingUsed(isGroupingUsed);
        }
        if (maxIntegerDigitsSpecified) {
            formatter.setMaximumIntegerDigits(maxIntegerDigits);
        }
        if (minIntegerDigitsSpecified) {
            formatter.setMinimumIntegerDigits(minIntegerDigits);
        }
        if (maxFractionDigitsSpecified) {
            formatter.setMaximumFractionDigits(maxFractionDigits);
        }
        if (minFractionDigitsSpecified) {
            formatter.setMinimumFractionDigits(minFractionDigits);
        }
    }

    /*

     * <1.4        EUR           \u20AC       \u20AC
     * >=1.4       EUR           \u20AC       Locale's currency symbol for Euro
     */

    private void setCurrency(NumberFormat formatter) throws Exception {
        String code = null;
        String symbol = null;

        if ((currencyCode == null) && (currencySymbol == null)) {
            return;
        }

        if ((currencyCode != null) && (currencySymbol != null)) {
            if (currencyClass != null) {
                code = currencyCode;
            } else {
                symbol = currencySymbol;
            }
        } else if (currencyCode == null) {
            symbol = currencySymbol;
        } else {
            if (currencyClass != null) {
                code = currencyCode;
            } else {
                symbol = currencyCode;
            }
        }

        if (code != null) {
            Object[] methodArgs = new Object[1];

            /*
            * java.util.Currency.getInstance()
            */
            Method m = currencyClass.getMethod("getInstance",
                    GET_INSTANCE_PARAM_TYPES);
            methodArgs[0] = code;
            Object currency = m.invoke(null, methodArgs);

            /*
            * java.text.NumberFormat.setCurrency()
            */
            Class[] paramTypes = new Class[1];
            paramTypes[0] = currencyClass;
            Class numberFormatClass = Class.forName("java.text.NumberFormat");
            m = numberFormatClass.getMethod("setCurrency", paramTypes);
            methodArgs[0] = currency;
            m.invoke(formatter, methodArgs);
        } else {
            /*
            * Let potential ClassCastException propagate up (will almost
            * never happen)
            */
            DecimalFormat df = (DecimalFormat) formatter;
            DecimalFormatSymbols dfs = df.getDecimalFormatSymbols();
            dfs.setCurrencySymbol(symbol);
            df.setDecimalFormatSymbols(dfs);
        }
    }
}




 * 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.taglibs.standard.tag.common.core;


 */

public abstract class UrlSupport extends BodyTagSupport
        implements ParamParent {

    //*********************************************************************
    // Protected state

    protected String value;                      // 'value' attribute
    protected String context;             // 'context' attribute

    //*********************************************************************
    // Private state

    private String var;                          // 'var' attribute
    private int scope;                 // processed 'scope' attr
    private ParamSupport.ParamManager params;     // added parameters

    //*********************************************************************
    // Constructor and initialization

    public UrlSupport() {
        super();
        init();
    }

    private void init() {
        value = var = null;
        params = null;
        context = null;
        scope = PageContext.PAGE_SCOPE;
    }


    //*********************************************************************
    // Tag attributes known at translation time

    public void setVar(String var) {

    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }



    // Collaboration with subtags

    // inherit Javadoc

    public void addParameter(String name, String value) {
        params.addParameter(name, value);
    }



    // Tag logic

    // resets any parameters that might be sent

    @Override
    public int doStartTag() throws JspException {
        params = new ParamSupport.ParamManager();
        return EVAL_BODY_BUFFERED;
    }


    // gets the right value, encodes it, and prints or stores it

    @Override
    public int doEndTag() throws JspException {
        String result;                // the eventual result

        // add (already encoded) parameters
        String baseUrl = resolveUrl(value, context, pageContext);
        result = params.aggregateParams(baseUrl);

        // if the URL is relative, rewrite it
        if (!ImportSupport.isAbsoluteUrl(result)) {
            HttpServletResponse response =
                    ((HttpServletResponse) pageContext.getResponse());
            result = response.encodeURL(result);
        }

        // store or print the output
        if (var != null) {
            pageContext.setAttribute(var, result, scope);
        } else {
            try {
                pageContext.getOut().print(result);
            } catch (java.io.IOException ex) {
                throw new JspTagException(ex.toString(), ex);
            }
        }

        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }

    //*********************************************************************


    public static String resolveUrl(
            String url, String context, PageContext pageContext)
            throws JspException {
        // don't touch absolute URLs
        if (ImportSupport.isAbsoluteUrl(url)) {
            return url;
        }

        // normalize relative URLs against a context root
        HttpServletRequest request =
                (HttpServletRequest) pageContext.getRequest();
        if (context == null) {
            if (url.startsWith("/")) {
                return (request.getContextPath() + url);
            } else {
                return url;
            }
        } else {
            if (!context.startsWith("/") || !url.startsWith("/")) {
                throw new JspTagException(
                        Resources.getMessage("IMPORT_BAD_RELATIVE"));
            }
            if (context.endsWith("/") && url.startsWith("/")) {
                // Don't produce string starting with '//', many




 * 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.taglibs.standard.tag.common.core;

import org.apache.taglibs.standard.util.EscapeXML;

import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.BodyTagSupport;

import org.apache.taglibs.standard.util.EscapeXML;

/**
 * <p>Support for handlers of the &lt;out&gt; tag, which simply evalutes and
 * prints the result of the expression it's passed.  If the result is

    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        output = null;


        // output default if supplied
        output = evalDefault();
        if (output != null) {
            return SKIP_BODY;
        }





 * 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.taglibs.standard.tag.common.core;


 * ForEach-specific functionality.  The rtexprvalue library and the
 * expression-evaluating library each have handlers that extend this
 * class.</p>
 * <p/>
 * <p>Localized here is the logic for handling the veritable smorgasbord
 * of types supported by &lt;forEach&gt;, including arrays,
 * Collections, and others.  To see how the actual iteration is controlled,
 * review the javax.servlet.jsp.jstl.core.LoopTagSupport class instead.
 * </p>
 *
 * @author Shawn Bayern
 * @see javax.servlet.jsp.jstl.core.LoopTagSupport
 * @author Shawn Bayern
 */

public abstract class ForEachSupport extends LoopTagSupport {

     * instead of in advance, would involve changing only those methods that
     * handle primitive arrays.
     */

    protected static interface ForEachIterator {
        public boolean hasNext() throws JspTagException;

        public Object next() throws JspTagException;
    }


     * an Iterator.  This is appropriate for cases where hasNext() and
     * next() don't need to throw JspTagException.  Such cases are common.core.
     */

    protected class SimpleForEachIterator implements ForEachIterator {
        private Iterator i;

        public SimpleForEachIterator(Iterator i) {
            this.i = i;
        }

        public boolean hasNext() {
            return i.hasNext();
        }

        public Object next() {
            return i.next();
        }
    }

    protected class DeferredForEachIterator implements ForEachIterator {

        private ValueExpression itemsValueExpression;

        private Iterator myIterator;
        private boolean anEnumeration = false;
        private Enumeration myEnumeration;

        public DeferredForEachIterator(ValueExpression o) throws JspTagException {
            itemsValueExpression = o;
            determineLengthAndType();
        }

        public boolean hasNext() throws JspTagException {
            if (isIndexedValueExpression) {
                if (currentIndex < length) {
                    return true;
                } else {
                    return false;
                }
            } else {
                if (length != -1) {
                    //a Collection, Map, or StringTokenizer 
                    if (currentIndex < length) {
                        return true;
                    } else {
                        return false;

                }
            }
        }

        public Object next() throws JspTagException {
            ValueExpression nextValue = null;
            if (isIndexedValueExpression) {
                nextValue = new IndexedValueExpression(itemsValueExpression, currentIndex);
                currentIndex++;
            } else {
                if (itemsValueIteratedExpression == null) {
                    itemsValueIteratedExpression = new IteratedExpression(itemsValueExpression, getDelims());
                }
                nextValue = new IteratedValueExpression(itemsValueIteratedExpression, currentIndex);
                currentIndex++;
                if (length != -1) {
                    //a Collection, Map, or StringTokenizer
                    //nothing else needed
                } else {

            }
            return nextValue;
        }

        private void determineLengthAndType() throws JspTagException {
            ELContext myELContext = pageContext.getELContext();
            Object o = itemsValueExpression.getValue(myELContext);
            if (o instanceof Object[]) {
                length = ((Object[]) o).length;
                isIndexedValueExpression = true;
            } else if (o instanceof boolean[]) {
                length = ((boolean[]) o).length;
                isIndexedValueExpression = true;
            } else if (o instanceof byte[]) {
                length = ((byte[]) o).length;
                isIndexedValueExpression = true;
            } else if (o instanceof char[]) {
                length = ((char[]) o).length;
                isIndexedValueExpression = true;
            } else if (o instanceof short[]) {
                length = ((short[]) o).length;
                isIndexedValueExpression = true;
            } else if (o instanceof int[]) {
                length = ((int[]) o).length;
                isIndexedValueExpression = true;
            } else if (o instanceof long[]) {
                length = ((long[]) o).length;
                isIndexedValueExpression = true;
            } else if (o instanceof float[]) {
                length = ((float[]) o).length;
                isIndexedValueExpression = true;
            } else if (o instanceof double[]) {
                length = ((double[]) o).length;
                isIndexedValueExpression = true;
            } else if (o instanceof Collection) {
                length = ((Collection) o).size();
                isIndexedValueExpression = false;
            } else if (o instanceof Iterator) {
                //have to reproduce iterator here so we can determine the size
                isIndexedValueExpression = false;
                anIterator = true;
                myIterator = (Iterator) o;
            } else if (o instanceof Enumeration) {
                isIndexedValueExpression = false;
                anEnumeration = true;
                myEnumeration = (Enumeration) o;
            } else if (o instanceof Map) {
                length = ((Map) o).size();
                isIndexedValueExpression = false;
                //
                //else if (o instanceof ResultSet)
                //    items = toForEachIterator((ResultSet) o);
                //
            } else if (o instanceof String) {
                StringTokenizer st = new StringTokenizer((String) o, ",");
                length = st.countTokens();
                isIndexedValueExpression = false;
            } else {

        // produce the right sort of ForEachIterator
        if (rawItems != null) {
            if (rawItems instanceof ValueExpression) {
                deferredExpression = (ValueExpression) rawItems;
                items = toDeferredForEachIterator(deferredExpression);
            } else {
                // extract an iterator over the 'items' we've got

        /* ResultSet no more supported in <c:forEach>
        // step must be 1 when ResultSet is passed in
        if (rawItems instanceof ResultSet && step != 1)
            throw new JspTagException(Resources.getMessage("FOREACH_STEP_NO_RESULTSET"));
		Resources.getMessage("FOREACH_STEP_NO_RESULTSET"));
        */
    }


    // Tag logic and lifecycle management

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();


    /* Extracts a ForEachIterator given an object of a supported type. */
    //This should not be called for a deferred ValueExpression

    protected ForEachIterator supportedTypeForEachIterator(Object o)
            throws JspTagException {



        ForEachIterator items;

        if (o instanceof Object[]) {
            items = toForEachIterator((Object[]) o);
        } else if (o instanceof boolean[]) {
            items = toForEachIterator((boolean[]) o);
        } else if (o instanceof byte[]) {
            items = toForEachIterator((byte[]) o);
        } else if (o instanceof char[]) {
            items = toForEachIterator((char[]) o);
        } else if (o instanceof short[]) {
            items = toForEachIterator((short[]) o);
        } else if (o instanceof int[]) {
            items = toForEachIterator((int[]) o);
        } else if (o instanceof long[]) {
            items = toForEachIterator((long[]) o);
        } else if (o instanceof float[]) {
            items = toForEachIterator((float[]) o);
        } else if (o instanceof double[]) {
            items = toForEachIterator((double[]) o);
        } else if (o instanceof Collection) {
            items = toForEachIterator((Collection) o);
        } else if (o instanceof Iterator) {
            items = toForEachIterator((Iterator) o);
        } else if (o instanceof Enumeration) {
            items = toForEachIterator((Enumeration) o);
        } else if (o instanceof Map) {
            items = toForEachIterator((Map) o);
        }
        /*
        else if (o instanceof ResultSet)
            items = toForEachIterator((ResultSet) o);
        */
        else if (o instanceof String) {
            items = toForEachIterator((String) o);
        } else {
            items = toForEachIterator(o);
        }

        return (items);
    }

     * in support of cases where our tag handler isn't passed an
     * explicit collection over which to iterate.
     */

    private ForEachIterator beginEndForEachIterator() {
        /*
         * To plug into existing support, we need to keep 'begin', 'end',

         * wouldn't provide much benefit.)
         */
        Integer[] ia = new Integer[end + 1];
        for (int i = 0; i <= end; i++) {
            ia[i] = new Integer(i);
        }
        return new SimpleForEachIterator(Arrays.asList(ia).iterator());
    }


    protected ForEachIterator toDeferredForEachIterator(ValueExpression o) throws JspTagException {
        return new DeferredForEachIterator(o);
    }

    // catch-all method whose invocation currently signals a 'matching error'

    protected ForEachIterator toForEachIterator(Object o)
            throws JspTagException {
        throw new JspTagException(Resources.getMessage("FOREACH_BAD_ITEMS"));
    }

    // returns an iterator over an Object array (via List)

    protected ForEachIterator toForEachIterator(Object[] a) {
        return new SimpleForEachIterator(Arrays.asList(a).iterator());
    }

    // returns an iterator over a boolean[] array, wrapping items in Boolean

    protected ForEachIterator toForEachIterator(boolean[] a) {
        Boolean[] wrapped = new Boolean[a.length];
        for (int i = 0; i < a.length; i++) {

    }

    // returns an iterator over a byte[] array, wrapping items in Byte

    protected ForEachIterator toForEachIterator(byte[] a) {
        Byte[] wrapped = new Byte[a.length];
        for (int i = 0; i < a.length; i++) {
            wrapped[i] = new Byte(a[i]);
        }
        return new SimpleForEachIterator(Arrays.asList(wrapped).iterator());
    }

    // returns an iterator over a char[] array, wrapping items in Character

    protected ForEachIterator toForEachIterator(char[] a) {
        Character[] wrapped = new Character[a.length];
        for (int i = 0; i < a.length; i++) {
            wrapped[i] = new Character(a[i]);
        }
        return new SimpleForEachIterator(Arrays.asList(wrapped).iterator());
    }

    // returns an iterator over a short[] array, wrapping items in Short

    protected ForEachIterator toForEachIterator(short[] a) {
        Short[] wrapped = new Short[a.length];
        for (int i = 0; i < a.length; i++) {
            wrapped[i] = new Short(a[i]);
        }
        return new SimpleForEachIterator(Arrays.asList(wrapped).iterator());
    }

    // returns an iterator over an int[] array, wrapping items in Integer

    protected ForEachIterator toForEachIterator(int[] a) {
        Integer[] wrapped = new Integer[a.length];
        for (int i = 0; i < a.length; i++) {
            wrapped[i] = new Integer(a[i]);
        }
        return new SimpleForEachIterator(Arrays.asList(wrapped).iterator());
    }

    // returns an iterator over a long[] array, wrapping items in Long

    protected ForEachIterator toForEachIterator(long[] a) {
        Long[] wrapped = new Long[a.length];
        for (int i = 0; i < a.length; i++) {
            wrapped[i] = new Long(a[i]);
        }
        return new SimpleForEachIterator(Arrays.asList(wrapped).iterator());
    }

    // returns an iterator over a float[] array, wrapping items in Float

    protected ForEachIterator toForEachIterator(float[] a) {
        Float[] wrapped = new Float[a.length];
        for (int i = 0; i < a.length; i++) {
            wrapped[i] = new Float(a[i]);
        }
        return new SimpleForEachIterator(Arrays.asList(wrapped).iterator());
    }

    // returns an iterator over a double[] array, wrapping items in Double

    protected ForEachIterator toForEachIterator(double[] a) {
        Double[] wrapped = new Double[a.length];
        for (int i = 0; i < a.length; i++) {
            wrapped[i] = new Double(a[i]);
        }
        return new SimpleForEachIterator(Arrays.asList(wrapped).iterator());
    }

    // retrieves an iterator from a Collection

    protected ForEachIterator toForEachIterator(Collection c) {
        return new SimpleForEachIterator(c.iterator());
    }

    // simply passes an Iterator through...

    protected ForEachIterator toForEachIterator(Iterator i) {
        return new SimpleForEachIterator(i);
    }

    // converts an Enumeration to an Iterator via a local adapter

    protected ForEachIterator toForEachIterator(Enumeration e) {

        // local adapter
        class EnumerationAdapter implements ForEachIterator {
            private Enumeration e;

            public EnumerationAdapter(Enumeration e) {
                this.e = e;
            }

            public boolean hasNext() {
                return e.hasMoreElements();
            }

            public Object next() {
                return e.nextElement();
            }

    }

    // retrieves an iterator over the Map.Entry items in a Map

    protected ForEachIterator toForEachIterator(Map m) {
        return new SimpleForEachIterator(m.entrySet().iterator());
    }

    */

    // tokenizes a String as a CSV and returns an iterator over it

    protected ForEachIterator toForEachIterator(String s) {
        StringTokenizer st = new StringTokenizer(s, ",");
        return toForEachIterator(st);           // convert from Enumeration

Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/common/core/OtherwiseTag.java (-1 / +2 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17		17
18	package org.apache.taglibs.standard.tag.common.core;	18	package org.apache.taglibs.standard.tag.common.core;
19		19
Lines 32-37 Link Here
32	*/	32	*/
33		33
34	// Don't let the condition stop us... :-)	34	// Don't let the condition stop us... :-)
		35
35	@Override	36	@Override
36	protected boolean condition() {	37	protected boolean condition() {
37	return true;	38	return true;




 * 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.taglibs.standard.tag.common.core;


 * @author Shawn Bayern
 */

public abstract class ImportSupport extends BodyTagSupport
        implements TryCatchFinally, ParamParent {

    //*********************************************************************
    // Public constants

    /**
     * <p>Valid characters in a scheme.</p>
     * <p>RFC 1738 says the following:</p>
     * <blockquote>
     * Scheme names consist of a sequence of characters. The lower
     * case letters "a"--"z", digits, and the characters plus ("+"),
     * period ("."), and hyphen ("-") are allowed. For resiliency,
     * programs interpreting URLs should treat upper case letters as
     * equivalent to lower case in scheme names (e.g., allow "HTTP" as
     * well as "http").
     * </blockquote>
     * <p>We treat as absolute any URL that begins with such a scheme name,
     * followed by a colon.</p>
     */
    public static final String VALID_SCHEME_CHARS =
            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+.-";

    /**
     * Default character encoding for response.
     */
    public static final String DEFAULT_ENCODING = "ISO-8859-1";

    //*********************************************************************
    // Protected state

    protected String url;                         // 'url' attribute
    protected String context;              // 'context' attribute
    protected String charEncoding;                // 'charEncoding' attrib.

    //*********************************************************************
    // Private state (implementation details)

    private String var;                 // 'var' attribute
    private int scope;            // processed 'scope' attribute
    private String varReader;           // 'varReader' attribute
    private Reader r;             // exposed reader, if relevant
    private boolean isAbsoluteUrl;    // is our URL absolute?
    private ParamSupport.ParamManager params;    // parameters
    private String urlWithParams;    // URL with parameters, if applicable

    //*********************************************************************
    // Constructor and initialization

    public ImportSupport() {
        super();
        init();
    }

    private void init() {
        url = var = varReader = context = charEncoding = urlWithParams = null;
        params = null;
        scope = PageContext.PAGE_SCOPE;
    }


    // Tag logic

    // determines what kind of import and variable exposure to perform 

    @Override
    public int doStartTag() throws JspException {
        // Sanity check
        if (context != null
                && (!context.startsWith("/") || !url.startsWith("/"))) {
            throw new JspTagException(
                    Resources.getMessage("IMPORT_BAD_RELATIVE"));
        }

        // reset parameter-related state
        urlWithParams = null;
        params = new ParamSupport.ParamManager();

        // check the URL
        if (url == null || url.equals("")) {
            throw new NullAttributeException("import", "url");
        }

        // Record whether our URL is absolute or relative
        isAbsoluteUrl = isAbsoluteUrl();

        try {
            // If we need to expose a Reader, we've got to do it right away
            if (varReader != null) {
                r = acquireReader();
                pageContext.setAttribute(varReader, r);
            }
        } catch (IOException ex) {
            throw new JspTagException(ex.toString(), ex);
        }

        return EVAL_BODY_INCLUDE;
    }

    // manages connections as necessary (creating or destroying)

    @Override
    public int doEndTag() throws JspException {
        try {
            // If we didn't expose a Reader earlier...
            if (varReader == null) {
                // ... store it in 'var', if available ...
                if (var != null) {
                    pageContext.setAttribute(var, acquireString(), scope);
                }
                // ... or simply output it, if we have nowhere to expose it
                else {
                    pageContext.getOut().print(acquireString());
                }
            }
            return EVAL_PAGE;
        } catch (IOException ex) {
            throw new JspTagException(ex.toString(), ex);
        }
    }

    // simply rethrows its exception

    public void doCatch(Throwable t) throws Throwable {
        throw t;
    }

    // cleans up if appropriate

    public void doFinally() {
        try {
            // If we exposed a Reader in doStartTag(), close it.
            if (varReader != null) {
                // 'r' can be null if an exception was thrown...
                if (r != null) {
                    r.close();
                }
                pageContext.removeAttribute(varReader, PageContext.PAGE_SCOPE);
            }
        } catch (IOException ex) {
            // ignore it; close() failed, but there's nothing more we can do
        }
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
        super.release();
    }


    // Tag attributes known at translation time

    public void setVar(String var) {
        this.var = var;
    }

    public void setVarReader(String varReader) {
        this.varReader = varReader;
    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }



    // Collaboration with subtags

    // inherit Javadoc

    public void addParameter(String name, String value) {
        params.addParameter(name, value);
    }

    //*********************************************************************

     */

    private String acquireString() throws IOException, JspException {
        if (isAbsoluteUrl) {
            // for absolute URLs, delegate to our peer
            BufferedReader r = new BufferedReader(acquireReader());
            StringBuffer sb = new StringBuffer();
            int i;

            // under JIT, testing seems to show this simple loop is as fast
            // as any of the alternatives
            while ((i = r.read()) != -1) {
                sb.append((char) i);
            }

            return sb.toString();
        } else {
            // handle relative URLs ourselves

            // URL is relative, so we must be an HTTP request
            if (!(pageContext.getRequest() instanceof HttpServletRequest
                    && pageContext.getResponse() instanceof HttpServletResponse)) {
                throw new JspTagException(
                        Resources.getMessage("IMPORT_REL_WITHOUT_HTTP"));
            }

            // retrieve an appropriate ServletContext
            ServletContext c = null;
            String targetUrl = targetUrl();
            if (context != null) {
                c = pageContext.getServletContext().getContext(context);
            } else {
                c = pageContext.getServletContext();

                // normalize the URL if we have an HttpServletRequest
                if (!targetUrl.startsWith("/")) {
                    String sp = ((HttpServletRequest)
                            pageContext.getRequest()).getServletPath();
                    targetUrl = sp.substring(0, sp.lastIndexOf('/'))
                            + '/' + targetUrl;
                }
            }

            if (c == null) {
                throw new JspTagException(
                        Resources.getMessage(
                                "IMPORT_REL_WITHOUT_DISPATCHER", context, targetUrl));
            }

            // from this context, get a dispatcher
            RequestDispatcher rd =
                    c.getRequestDispatcher(stripSession(targetUrl));
            if (rd == null) {
                throw new JspTagException(stripSession(targetUrl));
            }

            // include the resource, using our custom wrapper
            ImportResponseWrapper irw =
                    new ImportResponseWrapper(
                            (HttpServletResponse) pageContext.getResponse());

            ImportRequestWrapper wrappedRequest =
                    new ImportRequestWrapper(
                            (HttpServletRequest) pageContext.getRequest());

            // spec mandates specific error handling form include()
            try {
                rd.include(wrappedRequest, irw);
            } catch (IOException ex) {
                throw new JspException(ex);
            } catch (RuntimeException ex) {
                throw new JspException(ex);
            } catch (ServletException ex) {
                Throwable rc = ex.getRootCause();
                while (rc instanceof ServletException) {
                    rc = ((ServletException) rc).getRootCause();
                }
                if (rc == null) {
                    throw new JspException(ex);
                } else {
                    throw new JspException(rc);
                }
            }

            // disallow inappropriate response codes per JSTL spec
            if (irw.getStatus() < 200 || irw.getStatus() > 299) {
                throw new JspTagException(irw.getStatus() + " " +
                        stripSession(targetUrl));
            }

            // recover the response String from our wrapper
            return irw.getString();
        }
    }

    private Reader acquireReader() throws IOException, JspException {
        if (!isAbsoluteUrl) {
            // for relative URLs, delegate to our peer
            return new StringReader(acquireString());
        } else {
            // absolute URL
            String target = targetUrl();
            try {
                // handle absolute URLs ourselves, using java.net.URL
                URL u = new URL(target);
                URLConnection uc = u.openConnection();
                InputStream i = uc.getInputStream();

                // okay, we've got a stream; encode it appropriately
                Reader r = null;
                String charSet;
                if (charEncoding != null && !charEncoding.equals("")) {
                    charSet = charEncoding;
                } else {
                    // charSet extracted according to RFC 2045, section 5.1
                    String contentType = uc.getContentType();
                    if (contentType != null) {
                        charSet = Util.getContentTypeAttribute(contentType, "charset");
                        if (charSet == null) {
                            charSet = DEFAULT_ENCODING;
                        }
                    } else {
                        charSet = DEFAULT_ENCODING;
                    }

                    r = new InputStreamReader(i, DEFAULT_ENCODING);
                }

                // check response code for HTTP URLs before returning, per spec,
                // before returning
                if (uc instanceof HttpURLConnection) {
                    int status = ((HttpURLConnection) uc).getResponseCode();
                    if (status < 200 || status > 299) {
                        throw new JspTagException(status + " " + target);
                    }
                }

                return r;
            } catch (IOException ex) {
                throw new JspException(
                        Resources.getMessage("IMPORT_ABS_ERROR", target, ex), ex);
            } catch (RuntimeException ex) {  // because the spec makes us
                throw new JspException(
                        Resources.getMessage("IMPORT_ABS_ERROR", target, ex), ex);
            }
        }
    }

    /**
     * Wraps requests to allow us to enforce the method to be GET
     */
    private class ImportRequestWrapper extends HttpServletRequestWrapper {

        public ImportRequestWrapper(HttpServletRequest request) {
            super(request);
        }

        @Override
        public String getMethod() {
            return "GET";


    }

    /**
     * Wraps responses to allow us to retrieve results as Strings.
     */
    private class ImportResponseWrapper extends HttpServletResponseWrapper {

        //************************************************************
        // Overview

        /*
       * We provide either a Writer or an OutputStream as requested.
       * We actually have a true Writer and an OutputStream backing
       * both, since we don't want to use a character encoding both
       * ways (Writer -> OutputStream -> Writer).  So we use no
       * encoding at all (as none is relevant) when the target resource
       * uses a Writer.  And we decode the OutputStream's bytes
       * using OUR tag's 'charEncoding' attribute, or ISO-8859-1
       * as the default.  We thus ignore setLocale() and setContentType()
       * in this wrapper.
       *
       * In other words, the target's asserted encoding is used
       * to convert from a Writer to an OutputStream, which is typically
       * the medium through with the target will communicate its
       * ultimate response.  Since we short-circuit that mechanism
       * and read the target's characters directly if they're offered
       * as such, we simply ignore the target's encoding assertion.
       */

        //************************************************************
        // Data

        /**
         * The Writer we convey.
         */
        private StringWriter sw = new StringWriter();

        /**
         * A buffer, alternatively, to accumulate bytes.
         */
        private ByteArrayOutputStream bos = new ByteArrayOutputStream();

        /**
         * A ServletOutputStream we convey, tied to this Writer.
         */
        private ServletOutputStream sos = new ServletOutputStream() {
            @Override
            public void write(int b) throws IOException {
                bos.write(b);
            }
        };

        /**
         * 'True' if getWriter() was called; false otherwise.
         */
        private boolean isWriterUsed;

        /**
         * 'True if getOutputStream() was called; false otherwise.
         */
        private boolean isStreamUsed;

        /**
         * The HTTP status set by the target.
         */
        private int status = 200;
	// Constructor and methods

        //************************************************************
        // Constructor and methods
	    super(response);
	}
	
	/** Returns a Writer designed to buffer the output. */
	@Override
    public PrintWriter getWriter() {
	    if (isStreamUsed)
		throw new IllegalStateException(
		    Resources.getMessage("IMPORT_ILLEGAL_STREAM"));
	    isWriterUsed = true;
	    return new PrintWriter(sw);
	}
	
	/** Returns a ServletOutputStream designed to buffer the output. */
	@Override
    public ServletOutputStream getOutputStream() {
	    if (isWriterUsed)
		throw new IllegalStateException(
		    Resources.getMessage("IMPORT_ILLEGAL_WRITER"));
	    isStreamUsed = true;
	    return sos;
	}

        /**
         * Constructs a new ImportResponseWrapper.
         */
        public ImportResponseWrapper(HttpServletResponse response) {
            super(response);
        }

        /**
         * Returns a Writer designed to buffer the output.
         */
        @Override
        public PrintWriter getWriter() {
            if (isStreamUsed) {
                throw new IllegalStateException(
                        Resources.getMessage("IMPORT_ILLEGAL_STREAM"));
            }
            isWriterUsed = true;
            return new PrintWriter(sw);
        }

        /**
         * Returns a ServletOutputStream designed to buffer the output.
         */
        @Override
        public ServletOutputStream getOutputStream() {
            if (isWriterUsed) {
                throw new IllegalStateException(
                        Resources.getMessage("IMPORT_ILLEGAL_WRITER"));
            }
            isStreamUsed = true;
            return sos;
        }

        /**
         * Has no effect.
         */
        @Override
        public void setContentType(String x) {
            // ignore
        }

        /**
         * Has no effect.
	 * 'charEncoding' attribute, or the tag's default encoding,
	 * <b>if necessary</b>.
         */
        @Override
        public void setLocale(Locale x) {
            // ignore
        }

        @Override
        public void setStatus(int status) {
            this.status = status;
        }

        public int getStatus() {
            return status;
        }

        /**
         * Retrieves the buffered output, using the containing tag's
         * 'charEncoding' attribute, or the tag's default encoding,
         * <b>if necessary</b>.
         */
        // not simply toString() because we need to throw
        // UnsupportedEncodingException
        public String getString() throws UnsupportedEncodingException {
            if (isWriterUsed) {
                return sw.toString();
            } else if (isStreamUsed) {
                if (charEncoding != null && !charEncoding.equals("")) {
                    return bos.toString(charEncoding);
                } else {
                    return bos.toString(DEFAULT_ENCODING);
                }
            } else {
                return "";
            }        // target didn't write anything
        }
    }

    //*********************************************************************
    // Some private utility methods

    /**
     * Returns our URL (potentially with parameters)
     */
    private String targetUrl() {
        if (urlWithParams == null) {
            urlWithParams = params.aggregateParams(url);
        }
        return urlWithParams;
    }

    /**

     * <tt>false</tt> otherwise.
     */
    public static boolean isAbsoluteUrl(String url) {
        // a null URL is not absolute, by our definition
        if (url == null) {
            return false;
        }

        // do a fast, simple check first
        int colonPos;
        if ((colonPos = url.indexOf(":")) == -1) {
            return false;
        }

        // if we DO have a colon, make sure that every character
        // leading up to it is a valid scheme character
        for (int i = 0; i < colonPos; i++) {
            if (VALID_SCHEME_CHARS.indexOf(url.charAt(i)) == -1) {
                return false;
            }
        }

        // if so, we've got an absolute url
        return true;
    }

    /**

     * and either EOS or a subsequent ';' (exclusive).
     */
    public static String stripSession(String url) {
        StringBuffer u = new StringBuffer(url);
        int sessionStart;
        while ((sessionStart = u.toString().indexOf(";jsessionid=")) != -1) {
            int sessionEnd = u.toString().indexOf(";", sessionStart + 1);
            if (sessionEnd == -1) {
                sessionEnd = u.toString().indexOf("?", sessionStart + 1);
            }
            if (sessionEnd == -1)                 // still
            {
                sessionEnd = u.length();
            }
            u.delete(sessionStart, sessionEnd);
        }
        return u.toString();




 * 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.taglibs.standard.tag.common.core;


 * expression-evaluating libraries each have handlers that extend this
 * class.</p>
 *
 * @author Shawn Bayern
 * @see javax.servlet.jsp.jstl.core.LoopTagSupport
 * @author Shawn Bayern
 */

public abstract class ForTokensSupport extends LoopTagSupport {

            ELContext myELContext = pageContext.getELContext();
            Object originalValue = deferredExpression.getValue(myELContext);
            if (originalValue instanceof String) {
                st = new StringTokenizer((String) originalValue, delims);
            } else {
                throw new JspTagException();
            }
        } else {
            st = new StringTokenizer((String) items, delims);
        }
    }



    @Override
    protected Object next() throws JspTagException {
        if (deferredExpression != null) {
            st.nextElement();
            if (itemsValueIteratedExpression == null) {
                itemsValueIteratedExpression = new IteratedExpression(deferredExpression, getDelims());
            }
            ValueExpression nextValue = new IteratedValueExpression(itemsValueIteratedExpression, currentIndex);



    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();

Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/common/core/ParamParent.java (-1 / +1 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17		17
18	package org.apache.taglibs.standard.tag.common.core;	18	package org.apache.taglibs.standard.tag.common.core;
19		19




 * 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.taglibs.standard.tag.common.core;



/**
 * <p>Tag handler for &lt;choose&gt; in JSTL.</p>
 * <p/>
 * <p>&lt;choose&gt; is a very simple tag that acts primarily as a container;
 * it always includes its body and allows exactly one of its child
 * &lt;when&gt; tags to run.  Since this tag handler doesn't have any

    // Constructor and lifecycle management

    // initialize inherited and local state

    public ChooseTag() {
        super();
        init();
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();

     * body.
     */
    public synchronized void subtagSucceeded() {
        if (subtagGateClosed) {
            throw new IllegalStateException(
                    Resources.getMessage("CHOOSE_EXCLUSIVITY"));
        }
        subtagGateClosed = true;
    }


    // Tag logic

    // always include body

    @Override
    public int doStartTag() throws JspException {
        subtagGateClosed = false;    // when we start, no children have run
        return EVAL_BODY_INCLUDE;
    }


Lines 13-19 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/common/core/NullAttributeException.java (-2 / +2 lines)
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and	14	* See the License for the specific language governing permissions and
15	* limitations under the License.	15	* limitations under the License.
16	*/	16	*/
17		17
18	package org.apache.taglibs.standard.tag.common.core;	18	package org.apache.taglibs.standard.tag.common.core;
19		19
Lines 38-43 Link Here
38	* @param att The attribute value for which the error occurred.	38	* @param att The attribute value for which the error occurred.
39	*/	39	*/
40	public NullAttributeException(String tag, String att) {	40	public NullAttributeException(String tag, String att) {
41	super(Resources.getMessage("TAG_NULL_ATTRIBUTE", att, tag));	41	super(Resources.getMessage("TAG_NULL_ATTRIBUTE", att, tag));
42	}	42	}
43	}	43	}




 * 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.taglibs.standard.tag.common.core;


 */
public class Util {

    private static final String REQUEST = "request";
    private static final String SESSION = "session";
    private static final String APPLICATION = "application";
    private static final String DEFAULT = "default";
    private static final String SHORT = "short";
    private static final String MEDIUM = "medium";

     *
     * @return PageContext constant corresponding to given scope description
     */

    public static int getScope(String scope) {
        int ret = PageContext.PAGE_SCOPE; // default

        if (REQUEST.equalsIgnoreCase(scope)) {
            ret = PageContext.REQUEST_SCOPE;
        } else if (SESSION.equalsIgnoreCase(scope)) {
            ret = PageContext.SESSION_SCOPE;
        } else if (APPLICATION.equalsIgnoreCase(scope)) {
            ret = PageContext.APPLICATION_SCOPE;
        }

        return ret;
    }

    /*

     *
     * @throws JspException if the given style is invalid
     */

    public static int getStyle(String style, String errCode)
            throws JspException {
        int ret = DateFormat.DEFAULT;

        if (style != null) {
            if (DEFAULT.equalsIgnoreCase(style)) {
                ret = DateFormat.DEFAULT;
            } else if (SHORT.equalsIgnoreCase(style)) {
                ret = DateFormat.SHORT;
            } else if (MEDIUM.equalsIgnoreCase(style)) {
                ret = DateFormat.MEDIUM;
            } else if (LONG.equalsIgnoreCase(style)) {
                ret = DateFormat.LONG;
            } else if (FULL.equalsIgnoreCase(style)) {
                ret = DateFormat.FULL;
            } else {
                throw new JspException(Resources.getMessage(errCode, style));
            }
        }

        return ret;
    }



     * Syntax defined in RFC 2045, section 5.1.
     */
    public static String getContentTypeAttribute(String input, String name) {
        int begin;
        int end;
        int index = input.toUpperCase().indexOf(name.toUpperCase());
        if (index == -1) {
            return null;
        }
        index = index + name.length(); // positioned after the attribute name
        index = input.indexOf('=', index); // positioned at the '='
        if (index == -1) {
            return null;
        }
        index += 1; // positioned after the '='
        input = input.substring(index).trim();

        if (input.charAt(0) == '"') {
            // attribute value is a quoted string
            begin = 1;
            end = input.indexOf('"', begin);
            if (end == -1) {
                return null;
            }
        } else {
            begin = 0;
            end = input.indexOf(';');
            if (end == -1) {
                end = input.indexOf(' ');
            }
            if (end == -1) {
                end = input.length();
            }
        }
        return input.substring(begin, end).trim();
    }

    /**
     * HttpServletRequest.getLocales() returns the server's default locale
     * if the request did not specify a preferred language.
     * We do not want this behavior, because it prevents us from using
     * the fallback locale.
     * We therefore need to return an empty Enumeration if no preferred
     * locale has been specified. This way, the logic for the fallback
     * locale will be able to kick in.
     */
    public static Enumeration getRequestLocales(HttpServletRequest request) {
        Enumeration values = request.getHeaders("accept-language");
        if (values == null) {
            // No header for "accept-language". Simply return
            // a new empty enumeration.
            // System.out.println("Null accept-language");
            return new Vector().elements();
        } else if (values.hasMoreElements()) {
        if (values.hasMoreElements()) {
            // At least one "accept-language". Simply return
            // the enumeration returned by request.getLocales().
            // System.out.println("At least one accept-language");




 * 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.taglibs.standard.tag.common.core;



/**
 * <p>Tag handler for &lt;catch&gt; in JSTL 1.0.</p>
 * <p/>
 * <p>&lt;catch&gt; simply catches any Throwables that occur in its body
 * and optionally exposes them.
 *

    // Constructor and lifecycle management

    // initialize inherited and local state

    public CatchTag() {
        super();
        init();
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();

    @Override
    public int doStartTag() {
        caught = false;
        return EVAL_BODY_INCLUDE;
    }

    public void doCatch(Throwable t) {
        if (var != null) {
            pageContext.setAttribute(var, t, PageContext.PAGE_SCOPE);
        }
        caught = true;
    }

    public void doFinally() {
        if (var != null && !caught) {
            pageContext.removeAttribute(var, PageContext.PAGE_SCOPE);
        }
    }






 * 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.taglibs.standard.tag.common.core;

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import java.util.Map;

import javax.el.ELContext;
import javax.el.ELException;
import javax.el.ExpressionFactory;
import javax.el.ValueExpression;
import javax.el.VariableMapper;
import javax.servlet.jsp.JspApplicationContext;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspFactory;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.PageContext;

import javax.el.ELException;
import javax.el.ELContext;
import javax.el.ValueExpression;
import javax.el.VariableMapper;
import javax.el.ExpressionFactory;

import javax.servlet.jsp.tagext.BodyTagSupport;

import org.apache.taglibs.standard.resources.Resources;

    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        var = null;

                if (scopeValue != PageContext.PAGE_SCOPE) {
                    throw new JspTagException(Resources.getMessage("SET_BAD_DEFERRED_SCOPE", scope));
                }
                vm.setVariable(var, (ValueExpression) result);
            } else {
                // make sure to remove it from the VariableMapper if we will be setting into page scope
                if (scopeValue == PageContext.PAGE_SCOPE && vm.resolveVariable(var) != null) {

            }
        } else {
            //make sure to remove it from the Var mapper
            if (vm.resolveVariable(var) != null) {
                vm.setVariable(var, null);
            }
            if (scope != null) {

    /**
     * Export the result into a Map.
     *
     * @param target   the Map to export into
     * @param property the key to export into
     * @param result   the value to export
     */
    void exportToMapProperty(Object target, String property, Object result) {
        @SuppressWarnings("unchecked")

    /**
     * Export the result into a bean property.
     *
     * @param target   the bean to export into
     * @param property the bean property to set
     * @param result   the value to export
     * @throws JspTagException if there was a problem exporting the result
     */
    void exportToBeanProperty(Object target, String property, Object result) throws JspTagException {

     * rules of the Expression Language.
     *
     * @param value the value to convert
     * @param m     the setter method
     * @return value converted to an instance of the expected type; will be null if value was null
     * @throws javax.el.ELException if there was a problem coercing the value
     */




 * 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.taglibs.standard.tag.common.core;


    //*********************************************************************
    // Internal state

    private int scope;                    // tag attribute
    private boolean scopeSpecified;            // ... by tag attribute
    private String var;                    // tag attribute


    //*********************************************************************

    }

    // resets local state

    private void init() {
        var = null;
        scope = PageContext.PAGE_SCOPE;

    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        super.release();

    // Tag logic

    // removes the variable (from a specific scope, if specified)

    @Override
    public int doEndTag() throws JspException {
        if (!scopeSpecified) {
            pageContext.removeAttribute(var);
        } else {
            pageContext.removeAttribute(var, scope);
        }
        return EVAL_PAGE;
    }



    // Accessor methods

    // for tag attribute

    public void setVar(String var) {
        this.var = var;
    }

    // for tag attribute

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
        scopeSpecified = true;
    }
}




 * 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.taglibs.standard.tag.common.core;


 * implementation of &lt;when&gt;-style tags in both the rtexprvalue
 * and expression-evaluating libraries.  It also supports
 * &lt;otherwise&gt;.</p>
 * <p/>
 * <p>In particular, this base class does the following:</p>
 * <p/>
 * <ul>
 * <li> overrides ConditionalTagSupport.doStartTag() to implement the
 * appropriate semantics of subtags of &lt;choose&gt; </li>
 * </ul>
 *
 * @author Shawn Bayern
 */
public abstract class WhenTagSupport extends ConditionalTagSupport {
{
    //*********************************************************************
    // Implementation of exclusive-conditional behavior


     * ChooseTag wants it to do so.  The condition will not even be
     * evaluated if ChooseTag instructs us not to run.
     */

    @Override
    public int doStartTag() throws JspException {

        Tag parent;

        // make sure we're contained properly
        if (!((parent = getParent()) instanceof ChooseTag)) {
            throw new JspTagException(
                    Resources.getMessage("WHEN_OUTSIDE_CHOOSE"));
        }

        // make sure our parent wants us to continue
        if (!((ChooseTag) parent).gainPermission()) {
            return SKIP_BODY;
        }                   // we've been reeled in

        // handle conditional behavior
        if (condition()) {
            ((ChooseTag) parent).subtagSucceeded();
            return EVAL_BODY_INCLUDE;
        } else {
            return SKIP_BODY;
        }
    }
}




 * 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.taglibs.standard.tag.common.core;


 * <p>Support for tag handlers for &lt;param&gt;, the URL parameter
 * subtag for &lt;import&gt; in JSTL 1.0.</p>
 *
 * @author Shawn Bayern
 * @see ParamParent, ImportSupport, URLEncodeSupport
 * @author Shawn Bayern
 */

public abstract class ParamSupport extends BodyTagSupport {

    // Constructor and initialization

    public ParamSupport() {
        super();
        init();
    }

    private void init() {
        name = value = null;
    }

    //*********************************************************************
    // Tag logic

    // simply send our name and value to our appropriate ancestor

    @Override
    public int doEndTag() throws JspException {
        Tag t = findAncestorWithClass(this, ParamParent.class);
        if (t == null) {
            throw new JspTagException(
                    Resources.getMessage("PARAM_OUTSIDE_PARENT"));
        }

        // take no action for null or empty names
        if (name == null || name.equals("")) {
            return EVAL_PAGE;
        }

        // send the parameter to the appropriate ancestor
        ParamParent parent = (ParamParent) t;
        String value = this.value;
        if (value == null) {
            if (bodyContent == null || bodyContent.getString() == null) {
                value = "";
            } else {
                value = bodyContent.getString().trim();
            }
        }
        if (encode) {
            String enc = pageContext.getResponse().getCharacterEncoding();
            try {

        } else {
            parent.addParameter(name, value);
        }
        return EVAL_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }

    //*********************************************************************
    // Support for parameter management

    /**
     * Provides support for aggregating query parameters in URLs.
     * Specifically, accepts a series of parameters, ensuring that
     * - newer parameters will precede older ones in the output URL
     * - all supplied parameters precede those in the input URL
     */
    public static class ParamManager {

        //*********************************
        // Private state

        private List names = new LinkedList();
        private List values = new LinkedList();
        private boolean done = false;

        //*********************************
        // Public interface

        /**
         * Adds a new parameter to the list.
         */
        public void addParameter(String name, String value) {
            if (done) {
                throw new IllegalStateException();
            }
            if (name != null) {
                names.add(name);
                if (value != null) {
                    values.add(value);
                } else {
                    values.add("");
                }
            }
        }

        /**
         * Produces a new URL with the stored parameters, in the appropriate
         * order.
         */
        public String aggregateParams(String url) {
            /*
            * Since for efficiency we're destructive to the param lists,
            * we don't want to run multiple times.
            */
            if (done) {
                throw new IllegalStateException();
            }
            done = true;

            //// reverse the order of our two lists
            // Collections.reverse(this.names);
            // Collections.reverse(this.values);

            // build a string from the parameter list
            StringBuffer newParams = new StringBuffer();
            for (int i = 0; i < names.size(); i++) {
                newParams.append(names.get(i) + "=" + values.get(i));
                if (i < (names.size() - 1)) {
                    newParams.append("&");
                }
            }

            // insert these parameters into the URL as appropriate
            if (newParams.length() > 0) {
                int questionMark = url.indexOf('?');
                if (questionMark == -1) {
                    return (url + "?" + newParams);
                } else {
                    StringBuffer workingUrl = new StringBuffer(url);
                    workingUrl.insert(questionMark + 1, (newParams + "&"));
                    return workingUrl.toString();
                }
            } else {
                return url;
            }
        }
    }
}




 * 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.taglibs.standard.tag.common.core;


 */

public abstract class RedirectSupport extends BodyTagSupport
        implements ParamParent {

    //*********************************************************************
    // Protected state

    // Private state

    private String var;                          // 'var' attribute
    private int scope;                 // processed 'scope' attr
    private ParamSupport.ParamManager params;     // added parameters

    //*********************************************************************
    // Constructor and initialization

    public RedirectSupport() {
        super();
        init();
    }

    private void init() {
        url = var = null;
        params = null;
        scope = PageContext.PAGE_SCOPE;
    }


    //*********************************************************************
    // Tag attributes known at translation time

    public void setVar(String var) {

    }

    public void setScope(String scope) {
        this.scope = Util.getScope(scope);
    }



    // Collaboration with subtags

    // inherit Javadoc

    public void addParameter(String name, String value) {
        params.addParameter(name, value);
    }



    // Tag logic

    // resets any parameters that might be sent

    @Override
    public int doStartTag() throws JspException {
        params = new ParamSupport.ParamManager();
        return EVAL_BODY_BUFFERED;
    }


    // gets the right value, encodes it, and prints or stores it

    @Override
    public int doEndTag() throws JspException {
        String result;                // the eventual result

        // add (already encoded) parameters
        String baseUrl = UrlSupport.resolveUrl(url, context, pageContext);
        result = params.aggregateParams(baseUrl);

        // if the URL is relative, rewrite it with 'redirect' encoding rules
        HttpServletResponse response =
                ((HttpServletResponse) pageContext.getResponse());
        if (!ImportSupport.isAbsoluteUrl(result)) {
            result = response.encodeRedirectURL(result);
        }

        // redirect!
        try {
            response.sendRedirect(result);
        } catch (java.io.IOException ex) {
            throw new JspTagException(ex.toString(), ex);
        }

        return SKIP_PAGE;
    }

    // Releases any resources we may have (or inherit)

    @Override
    public void release() {
        init();
    }
}




 */
package org.apache.taglibs.standard.util;

import javax.servlet.jsp.JspWriter;
import java.io.IOException;
import java.io.Reader;

import javax.servlet.jsp.JspWriter;

/**
 * Handles escaping of characters that could be interpreted as XML markup.
 * <p/>
 * The specification for <code>&lt;c:out&gt;</code> defines the following
 * character conversions to be applied:
 * <p/>
 * <table rules="all" frame="border">
 * <thead align="center">
 * <tr><th>Character</th><th>Character Entity Code</th></tr>

public class EscapeXML {

    private static final String[] ESCAPES;

    static {
        int size = '>' + 1; // '>' is the largest escaped value
        ESCAPES = new String[size];


    /**
     * Emit the supplied object to the specified writer, escaping characters if needed.
     *
     * @param src       the object to write
     * @param escapeXml if true, escape unsafe characters before writing
     * @param out       the JspWriter to emit to
     * @throws IOException if there was a problem emitting the content
     */
    public static void emit(Object src, boolean escapeXml, JspWriter out) throws IOException {


    /**
     * Emit the supplied String to the specified writer, escaping characters if needed.
     *
     * @param src       the String to write
     * @param escapeXml if true, escape unsafe characters before writing
     * @param out       the JspWriter to emit to
     * @throws IOException if there was a problem emitting the content
     */
    public static void emit(String src, boolean escapeXml, JspWriter out) throws IOException {

    public static void emit(String src, JspWriter out) throws IOException {
        int end = src.length();
        int from = 0;
        for (int to = from; to < end; to++) {
            String escape = getEscape(src.charAt(to));
            if (escape != null) {
                if (to != from) {
                    out.write(src, from, to - from);
                }
                out.write(escape);
                from = to + 1;
            }
        }
        if (from != end) {
            out.write(src, from, end - from);
        }
    }

    /**
     * Copy the content of a Reader into the specified JSPWriter escaping characters if needed.
     *
     * @param src       the Reader to read from
     * @param escapeXml if true, escape characters
     * @param out       the JspWriter to emit to
     * @throws IOException if there was a problem emitting the content
     */
    public static void emit(Reader src, boolean escapeXml, JspWriter out) throws IOException {

     * Emit escaped content into the specified JSPWriter.
     *
     * @param buffer characters to escape
     * @param from   start position in the buffer
     * @param count  number of characters to emit
     * @param out    the JspWriter to emit to
     * @throws IOException if there was a problem emitting the content
     */
    public static void emit(char[] buffer, int from, int count, JspWriter out) throws IOException {
        int end = from + count;
        for (int to = from; to < end; to++) {
            String escape = getEscape(buffer[to]);
            if (escape != null) {
                if (to != from) {
                    out.write(buffer, from, to - from);
                }
                out.write(escape);
                from = to + 1;
            }
        }
        if (from != end) {
            out.write(buffer, from, end - from);
        }
    }
}

Lines 30-37 Link Here

(-)src/main/java/org/apache/taglibs/standard/util/ExpressionUtil.java (-2 / +2 lines)
30	/**	30	/**
31	* Create a value expression.	31	* Create a value expression.
32	*	32	*
33	* @param pageContext the context in which the expression will be parsed	33	* @param pageContext the context in which the expression will be parsed
34	* @param expression the expression	34	* @param expression the expression
35	* @param expectedType the expected type of result	35	* @param expectedType the expected type of result
36	* @return a parsed expression	36	* @return a parsed expression
37	*/	37	*/




<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib
        PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
        "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
    <tlib-version>1.0</tlib-version>
    <jsp-version>1.2</jsp-version>
    <short-name>sql_rt</short-name>
    <uri>http://java.sun.com/jstl/sql_rt</uri>
    <display-name>JSTL sql RT</display-name>
    <description>JSTL 1.0 sql library</description>

    <validator>
        <validator-class>
            org.apache.taglibs.standard.tlv.JstlSqlTLV
        </validator-class>
        <description>
            Provides core validation features for JSTL tags.
        </description>
    </validator>

    <tag>
        <name>transaction</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.TransactionTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Provides nested database action elements with a shared Connection,
            set up to execute all statements as one transaction.
        </description>
        <attribute>
            <name>dataSource</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>isolation</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>query</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.QueryTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Executes the SQL query defined in its body or through the
            sql attribute.
        </description>
        <attribute>
            <name>var</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>sql</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>dataSource</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>startRow</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>maxRows</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>update</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.UpdateTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Executes the SQL update defined in its body or through the
            sql attribute.
        </description>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>sql</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>dataSource</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>param</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.ParamTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Sets a parameter in an SQL statement to the specified value.
        </description>
        <attribute>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>dateParam</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.DateParamTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Sets a parameter in an SQL statement to the specified java.util.Date value.
        </description>
        <attribute>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>setDataSource</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.SetDataSourceTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Creates a simple DataSource suitable only for prototyping.
        </description>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>dataSource</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>driver</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>url</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>user</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>password</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>
</taglib>




<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
        version="2.0">
    
  <description>JSTL 1.1 sql library</description>
  <display-name>JSTL sql</display-name>
  <tlib-version>1.1</tlib-version>
  <short-name>sql</short-name>
  <uri>http://java.sun.com/jsp/jstl/sql</uri>

    <description>JSTL 1.1 sql library</description>
    <display-name>JSTL sql</display-name>
    <tlib-version>1.1</tlib-version>
    <short-name>sql</short-name>
    <uri>http://java.sun.com/jsp/jstl/sql</uri>
        org.apache.taglibs.standard.tlv.JstlSqlTLV
    </validator-class>
  </validator>

    <validator>
    <description>
        Provides nested database action elements with a shared Connection,
        set up to execute all statements as one transaction.
    </description>
    <name>transaction</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.sql.TransactionTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Provides core validation features for JSTL tags.
String value represents a relative path to a JNDI
resource or the parameters for the JDBC
DriverManager facility.
        </description>
        <validator-class>
            org.apache.taglibs.standard.tlv.JstlSqlTLV
        </validator-class>
    </validator>

    <tag>
        <description>
            Provides nested database action elements with a shared Connection,
            set up to execute all statements as one transaction.
with.
        </description>
        <name>transaction</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.TransactionTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                DataSource associated with the database to access. A
                String value represents a relative path to a JNDI
                resource or the parameters for the JDBC
                DriverManager facility.
            </description>
            <name>dataSource</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Transaction isolation level. If not specified, it is the
                isolation level the DataSource has been configured
                with.
            </description>
            <name>isolation</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Executes the SQL query defined in its body or through the
        sql attribute.
    </description>
    <name>query</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.sql.QueryTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Executes the SQL query defined in its body or through the
            sql attribute.
javax.servlet.jsp.jstl.sql.
Result (see Chapter 16 "Java APIs").
        </description>
        <name>query</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.QueryTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                query result. The type of the scoped variable is
                javax.servlet.jsp.jstl.sql.
                Result (see Chapter 16 "Java APIs").
            </description>
            <name>var</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope of var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                SQL query statement.
            </description>
            <name>sql</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Data source associated with the database to
                query. A String value represents a relative path
                to a JNDI resource or the parameters for the
                DriverManager class.
            </description>
            <name>dataSource</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                The returned Result object includes the rows
                starting at the specified index. The first row of
                the original query result set is at index 0. If not
                specified, rows are included starting from the
                first row at index 0.
            </description>
            <name>startRow</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                The maximum number of rows to be included in
                the query result. If not specified, or set to -1, no
                limit on the maximum number of rows is
                enforced.
            </description>
            <name>maxRows</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Executes the SQL update defined in its body or through the
        sql attribute.
    </description>
    <name>update</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.sql.UpdateTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Executes the SQL update defined in its body or through the
            sql attribute.
variable is java.lang.Integer.
        </description>
        <name>update</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.UpdateTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable for the result
                of the database update. The type of the scoped
                variable is java.lang.Integer.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope of var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                SQL update statement.
            </description>
            <name>sql</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Data source associated with the database to update.
                A String value represents a relative path to a JNDI
                resource or the parameters for the JDBC
                DriverManager class.
            </description>
            <name>dataSource</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Sets a parameter in an SQL statement to the specified value.
    </description>
    <name>param</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.sql.ParamTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Sets a parameter in an SQL statement to the specified value.
        </description>
        <name>param</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.ParamTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Parameter value.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Sets a parameter in an SQL statement to the specified java.util.Date value.
    </description>
    <name>dateParam</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.sql.DateParamTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Sets a parameter in an SQL statement to the specified java.util.Date value.
TIMESTAMP column in a database table.
        </description>
        <name>dateParam</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.DateParamTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                Parameter value for DATE, TIME, or
                TIMESTAMP column in a database table.
            </description>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                One of "date", "time" or "timestamp".
            </description>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Creates a simple DataSource suitable only for prototyping.
    </description>
    <name>setDataSource</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.sql.SetDataSourceTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Creates a simple DataSource suitable only for prototyping.
for the data source specified. Type can
be String or DataSource.
        </description>
        <name>setDataSource</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.sql.SetDataSourceTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable
                for the data source specified. Type can
                be String or DataSource.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                If var is specified, scope of the
                exported variable. Otherwise, scope of
                the data source configuration variable.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Data source. If specified as a string, it
                can either be a relative path to a JNDI
                resource, or a JDBC parameters string
                as defined in Section 10.1.1.
            </description>
            <name>dataSource</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                JDBC parameter: driver class name.
            </description>
            <name>driver</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                JDBC parameter: URL associated with
                the database.
            </description>
            <name>url</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                JDBC parameter: database user on
                whose behalf the connection to the
                database is being made.
            </description>
            <name>user</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                JDBC parameter: user password
            </description>
            <name>password</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>
</taglib>




<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
        version="2.0">
    
  <description>JSTL 1.1 core library</description>
  <display-name>JSTL core</display-name>
  <tlib-version>1.1</tlib-version>
  <short-name>c</short-name>
  <uri>http://java.sun.com/jsp/jstl/core_1_1</uri>

    <description>JSTL 1.1 core library</description>
    <display-name>JSTL core</display-name>
    <tlib-version>1.1</tlib-version>
    <short-name>c</short-name>
    <uri>http://java.sun.com/jsp/jstl/core_1_1</uri>
        org.apache.taglibs.standard.tlv.JstlCoreTLV
    </validator-class>
  </validator>

    <validator>
    <description>
        Catches any Throwable that occurs in its body and optionally
        exposes it.
    </description>
    <name>catch</name>
    <tag-class>org.apache.taglibs.standard.tag.common.core.CatchTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Provides core validation features for JSTL tags.
exception thrown from a nested action. The type of the
scoped variable is the type of the exception thrown.
        </description>
        <validator-class>
            org.apache.taglibs.standard.tlv.JstlCoreTLV
        </validator-class>
    </validator>
  </tag>

    <tag>
    <description>
	Simple conditional tag that establishes a context for
	mutually exclusive conditional operations, marked by
	&lt;when&gt; and &lt;otherwise&gt;
    </description>
    <name>choose</name>
    <tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
    <body-content>JSP</body-content>
  </tag>

  <tag>
    <description>
	Simple conditional tag, which evalutes its body if the
	supplied condition is true and optionally exposes a Boolean
	scripting variable representing the evaluation of this condition
    </description>
    <name>if</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.IfTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Catches any Throwable that occurs in its body and optionally
            exposes it.
        </description>
        <name>catch</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.CatchTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                exception thrown from a nested action. The type of the
                scoped variable is the type of the exception thrown.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <description>
            Simple conditional tag that establishes a context for
            mutually exclusive conditional operations, marked by
            &lt;when&gt; and &lt;otherwise&gt;
        </description>
        <name>choose</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
        <body-content>JSP</body-content>
    </tag>

    <tag>
        <description>
            Simple conditional tag, which evalutes its body if the
            supplied condition is true and optionally exposes a Boolean
            scripting variable representing the evaluation of this condition
        </description>
        <name>if</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.IfTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The test condition that determines whether or
                not the body content should be processed.
            </description>
            <name>test</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>boolean</type>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                resulting value of the test condition. The type
                of the scoped variable is Boolean.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Retrieves an absolute or relative URL and exposes its contents
        to either the page, a String in 'var', or a Reader in 'varReader'.
    </description>
    <name>import</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.ImportTag</tag-class>
    <tei-class>org.apache.taglibs.standard.tei.ImportTEI</tei-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Retrieves an absolute or relative URL and exposes its contents
            to either the page, a String in 'var', or a Reader in 'varReader'.
        </description>
        <name>import</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ImportTag</tag-class>
        <tei-class>org.apache.taglibs.standard.tei.ImportTEI</tei-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The URL of the resource to import.
            </description>
            <name>url</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                resource's content. The type of the scoped
                variable is String.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                resource's content. The type of the scoped
                variable is Reader.
            </description>
            <name>varReader</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the context when accessing a relative
                URL resource that belongs to a foreign
                context.
            </description>
            <name>context</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Character encoding of the content at the input
                resource.
            </description>
            <name>charEncoding</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
	The basic iteration tag, accepting many different
        collection types and supporting subsetting and other
        functionality
    </description>
    <name>forEach</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.ForEachTag</tag-class>
    <tei-class>org.apache.taglibs.standard.tei.ForEachTEI</tei-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            The basic iteration tag, accepting many different
            collection types and supporting subsetting and other
            functionality
        </description>
        <name>forEach</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ForEachTag</tag-class>
        <tei-class>org.apache.taglibs.standard.tei.ForEachTEI</tei-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Collection of items to iterate over.
            </description>
            <name>items</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.Object</type>
        </attribute>
        <attribute>
            <description>
                If items specified:
                Iteration begins at the item located at the
                specified index. First item of the collection has
                index 0.
                If items not specified:
                Iteration begins with index set at the value
                specified.
            </description>
            <name>begin</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                If items specified:
                Iteration ends at the item located at the
                specified index (inclusive).
                If items not specified:
                Iteration ends when index reaches the value
                specified.
            </description>
            <name>end</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Iteration will only process every step items of
                the collection, starting with the first one.
            </description>
            <name>step</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                current item of the iteration. This scoped
                variable has nested visibility. Its type depends
                on the object of the underlying collection.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                status of the iteration. Object exported is of type
                javax.servlet.jsp.jstl.core.LoopTagStatus. This scoped variable has nested
                visibility.
            </description>
            <name>varStatus</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
	Iterates over tokens, separated by the supplied delimeters
    </description>
    <name>forTokens</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.ForTokensTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Iterates over tokens, separated by the supplied delimeters
        </description>
        <name>forTokens</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ForTokensTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                String of tokens to iterate over.
            </description>
            <name>items</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>
                The set of delimiters (the characters that
                separate the tokens in the string).
            </description>
            <name>delims</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>
                Iteration begins at the token located at the
                specified index. First token has index 0.
            </description>
            <name>begin</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Iteration ends at the token located at the
                specified index (inclusive).
            </description>
            <name>end</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Iteration will only process every step tokens
                of the string, starting with the first one.
            </description>
            <name>step</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                current item of the iteration. This scoped
                variable has nested visibility.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                status of the iteration. Object exported is of
                type
                javax.servlet.jsp.jstl.core.LoopTag
                Status. This scoped variable has nested
                visibility.
            </description>
            <name>varStatus</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Like &lt;%= ... &gt;, but for expressions.
    </description> 
    <name>out</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.OutTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Like &lt;%= ... &gt;, but for expressions.
        </description>
        <name>out</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.OutTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Expression to be evaluated.
            </description>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Default value if the resulting value is null.
            </description>
            <name>default</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Determines whether characters &lt;,&gt;,&amp;,'," in the
                resulting string should be converted to their
                corresponding character entity codes. Default value is
                true.
            </description>
            <name>escapeXml</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>


    <tag>
    <description>
        Subtag of &lt;choose&gt; that follows &lt;when&gt; tags
        and runs only if all of the prior conditions evaluated to
        'false'
    </description>
    <name>otherwise</name>
    <tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
    <body-content>JSP</body-content>
  </tag>

  <tag>
    <description>
        Adds a parameter to a containing 'import' tag's URL.
    </description>
    <name>param</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.ParamTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Subtag of &lt;choose&gt; that follows &lt;when&gt; tags
            and runs only if all of the prior conditions evaluated to
            'false'
        </description>
        <name>otherwise</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
        <body-content>JSP</body-content>
    </tag>

    <tag>
        <description>
            Adds a parameter to a containing 'import' tag's URL.
        </description>
        <name>param</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ParamTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the query string parameter.
            </description>
            <name>name</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Value of the parameter.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Redirects to a new URL.
    </description>
    <name>redirect</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.RedirectTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Redirects to a new URL.
        </description>
        <name>redirect</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.RedirectTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The URL of the resource to redirect to.
            </description>
            <name>url</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the context when redirecting to a relative URL
                resource that belongs to a foreign context.
            </description>
            <name>context</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Removes a scoped variable (from a particular scope, if specified).
    </description>
    <name>remove</name>
    <tag-class>org.apache.taglibs.standard.tag.common.core.RemoveTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Removes a scoped variable (from a particular scope, if specified).
        </description>
        <name>remove</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.RemoveTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                Name of the scoped variable to be removed.
            </description>
            <name>var</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Sets the result of an expression evaluation in a 'scope'
    </description>
    <name>set</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.SetTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Sets the result of an expression evaluation in a 'scope'
specified in the action. The type of the scoped variable is
whatever type the value expression evaluates to.
        </description>
        <name>set</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.SetTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable to hold the value
                specified in the action. The type of the scoped variable is
                whatever type the value expression evaluates to.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Expression to be evaluated.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Target object whose property will be set. Must evaluate to
                a JavaBeans object with setter property property, or to a
                java.util.Map object.
            </description>
            <name>target</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the property to be set in the target object.
            </description>
            <name>property</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Creates a URL with optional query parameters.
    </description>
    <name>url</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.UrlTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Creates a URL with optional query parameters.
processed url. The type of the scoped variable is
String.
        </description>
        <name>url</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.UrlTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                processed url. The type of the scoped variable is
                String.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                URL to be processed.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the context when specifying a relative URL
                resource that belongs to a foreign context.
            </description>
            <name>context</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
	Subtag of &lt;choose&gt; that includes its body if its
	condition evalutes to 'true'
    </description>
    <name>when</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.WhenTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Subtag of &lt;choose&gt; that includes its body if its
            condition evalutes to 'true'
        </description>
        <name>when</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.WhenTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The test condition that determines whether or not the
                body content should be processed.
            </description>
            <name>test</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>boolean</type>
        </attribute>
    </tag>

</taglib>




<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib
        PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
        "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
    <tlib-version>1.0</tlib-version>
    <jsp-version>1.2</jsp-version>
    <short-name>c_rt</short-name>
    <uri>http://java.sun.com/jstl/core_rt</uri>
    <display-name>JSTL core RT</display-name>
    <description>JSTL 1.0 core library</description>

    <validator>
        <validator-class>
            org.apache.taglibs.standard.tlv.JstlCoreTLV
        </validator-class>
        <description>
            Provides core validation features for JSTL tags.
        </description>
    </validator>

    <tag>
        <name>catch</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.CatchTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Catches any Throwable that occurs in its body and optionally
            exposes it.
        </description>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>choose</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Simple conditional tag that establishes a context for
            mutually exclusive conditional operations, marked by
            &lt;when&gt; and &lt;otherwise&gt;
        </description>
    </tag>

    <tag>
        <name>if</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.IfTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Simple conditional tag, which evalutes its body if the
            supplied condition is true and optionally exposes a Boolean
            scripting variable representing the evaluation of this condition
        </description>
        <attribute>
            <name>test</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>boolean</type>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>import</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ImportTag</tag-class>
        <tei-class>org.apache.taglibs.standard.tei.ImportTEI</tei-class>
        <body-content>JSP</body-content>
        <description>
            Retrieves an absolute or relative URL and exposes its contents
            to either the page, a String in 'var', or a Reader in 'varReader'.
        </description>
        <attribute>
            <name>url</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>varReader</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>context</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>charEncoding</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>forEach</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ForEachTag</tag-class>
        <tei-class>org.apache.taglibs.standard.tei.ForEachTEI</tei-class>
        <body-content>JSP</body-content>
        <description>
            The basic iteration tag, accepting many different
            collection types and supporting subsetting and other
            functionality
        </description>
        <attribute>
            <name>items</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.Object</type>
        </attribute>
        <attribute>
            <name>begin</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <name>end</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <name>step</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>varStatus</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>forTokens</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ForTokensTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Iterates over tokens, separated by the supplied delimeters
        </description>
        <attribute>
            <name>items</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <name>delims</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <name>begin</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <name>end</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <name>step</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>varStatus</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>out</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.OutTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Like &lt;%= ... &gt;, but for expressions.
        </description>
        <attribute>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>default</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>escapeXml</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>


    <tag>
        <name>otherwise</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Subtag of &lt;choose&gt; that follows &lt;when&gt; tags
            and runs only if all of the prior conditions evaluated to
            'false'
        </description>
    </tag>

    <tag>
        <name>param</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ParamTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Adds a parameter to a containing 'import' tag's URL.
        </description>
        <attribute>
            <name>name</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>redirect</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.RedirectTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Redirects to a new URL.
        </description>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>url</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>context</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>remove</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.RemoveTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Removes a scoped variable (from a particular scope, if specified).
        </description>
        <attribute>
            <name>var</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>set</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.SetTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Sets the result of an expression evaluation in a 'scope'
        </description>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>target</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>property</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>url</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.UrlTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Creates a URL with optional query parameters.
        </description>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>context</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>when</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.WhenTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Subtag of &lt;choose&gt; that includes its body if its
            condition evalutes to 'true'
        </description>
        <attribute>
            <name>test</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>boolean</type>
        </attribute>
    </tag>

</taglib>




<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
        version="2.1">

    <description>JSTL 1.2 core library</description>
    <display-name>JSTL core</display-name>
    <tlib-version>1.2</tlib-version>
    <short-name>c</short-name>
    <uri>http://java.sun.com/jsp/jstl/core</uri>

    <validator>
    <description>
        Provides core validation features for JSTL tags.
    </description>
    <validator-class>
        org.apache.taglibs.standard.tlv.JstlCoreTLV
    </validator-class>
  </validator>

  <tag>
    <description>
        Catches any Throwable that occurs in its body and optionally
        exposes it.
    </description>
    <name>catch</name>
    <tag-class>org.apache.taglibs.standard.tag.common.core.CatchTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Provides core validation features for JSTL tags.
exception thrown from a nested action. The type of the
scoped variable is the type of the exception thrown.
        </description>
        <validator-class>
            org.apache.taglibs.standard.tlv.JstlCoreTLV
        </validator-class>
    </validator>
  </tag>

    <tag>
    <description>
	Simple conditional tag that establishes a context for
	mutually exclusive conditional operations, marked by
	&lt;when&gt; and &lt;otherwise&gt;
    </description>
    <name>choose</name>
    <tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
    <body-content>JSP</body-content>
  </tag>

  <tag>
    <description>
	Simple conditional tag, which evalutes its body if the
	supplied condition is true and optionally exposes a Boolean
	scripting variable representing the evaluation of this condition
    </description>
    <name>if</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.IfTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Catches any Throwable that occurs in its body and optionally
            exposes it.
        </description>
        <name>catch</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.CatchTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                exception thrown from a nested action. The type of the
                scoped variable is the type of the exception thrown.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <description>
            Simple conditional tag that establishes a context for
            mutually exclusive conditional operations, marked by
            &lt;when&gt; and &lt;otherwise&gt;
        </description>
        <name>choose</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
        <body-content>JSP</body-content>
    </tag>

    <tag>
        <description>
            Simple conditional tag, which evalutes its body if the
            supplied condition is true and optionally exposes a Boolean
            scripting variable representing the evaluation of this condition
        </description>
        <name>if</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.IfTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The test condition that determines whether or
                not the body content should be processed.
            </description>
            <name>test</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>boolean</type>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                resulting value of the test condition. The type
                of the scoped variable is Boolean.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Retrieves an absolute or relative URL and exposes its contents
        to either the page, a String in 'var', or a Reader in 'varReader'.
    </description>
    <name>import</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.ImportTag</tag-class>
    <tei-class>org.apache.taglibs.standard.tei.ImportTEI</tei-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Retrieves an absolute or relative URL and exposes its contents
            to either the page, a String in 'var', or a Reader in 'varReader'.
        </description>
        <name>import</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ImportTag</tag-class>
        <tei-class>org.apache.taglibs.standard.tei.ImportTEI</tei-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The URL of the resource to import.
            </description>
            <name>url</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                resource's content. The type of the scoped
                variable is String.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                resource's content. The type of the scoped
                variable is Reader.
            </description>
            <name>varReader</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the context when accessing a relative
                URL resource that belongs to a foreign
                context.
            </description>
            <name>context</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Character encoding of the content at the input
                resource.
            </description>
            <name>charEncoding</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
	The basic iteration tag, accepting many different
        collection types and supporting subsetting and other
        functionality
    </description>
    <name>forEach</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.ForEachTag</tag-class>
    <tei-class>org.apache.taglibs.standard.tei.ForEachTEI</tei-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            The basic iteration tag, accepting many different
            collection types and supporting subsetting and other
            functionality
        </description>
        <name>forEach</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ForEachTag</tag-class>
        <tei-class>org.apache.taglibs.standard.tei.ForEachTEI</tei-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Collection of items to iterate over.
            </description>
            <name>items</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.Object</type>
            <deferred-value>
                <type>java.lang.Object</type>
            </deferred-value>
        </attribute>
        <attribute>
            <description>
                If items specified:
                Iteration begins at the item located at the
                specified index. First item of the collection has
                index 0.
                If items not specified:
                Iteration begins with index set at the value
                specified.
            </description>
            <name>begin</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                If items specified:
                Iteration ends at the item located at the
                specified index (inclusive).
                If items not specified:
                Iteration ends when index reaches the value
                specified.
            </description>
            <name>end</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Iteration will only process every step items of
                the collection, starting with the first one.
            </description>
            <name>step</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                current item of the iteration. This scoped
                variable has nested visibility. Its type depends
                on the object of the underlying collection.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                status of the iteration. Object exported is of type
                javax.servlet.jsp.jstl.core.LoopTagStatus. This scoped variable has nested
                visibility.
            </description>
            <name>varStatus</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
	Iterates over tokens, separated by the supplied delimeters
    </description>
    <name>forTokens</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.ForTokensTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Iterates over tokens, separated by the supplied delimeters
        </description>
        <name>forTokens</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ForTokensTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                String of tokens to iterate over.
            </description>
            <name>items</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
            <deferred-value>
                <type>java.lang.String</type>
            </deferred-value>
        </attribute>
        <attribute>
            <description>
                The set of delimiters (the characters that
                separate the tokens in the string).
            </description>
            <name>delims</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>
                Iteration begins at the token located at the
                specified index. First token has index 0.
            </description>
            <name>begin</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Iteration ends at the token located at the
                specified index (inclusive).
            </description>
            <name>end</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Iteration will only process every step tokens
                of the string, starting with the first one.
            </description>
            <name>step</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                current item of the iteration. This scoped
                variable has nested visibility.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                status of the iteration. Object exported is of
                type
                javax.servlet.jsp.jstl.core.LoopTag
                Status. This scoped variable has nested
                visibility.
            </description>
            <name>varStatus</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Like &lt;%= ... &gt;, but for expressions.
    </description> 
    <name>out</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.OutTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Like &lt;%= ... &gt;, but for expressions.
        </description>
        <name>out</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.OutTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Expression to be evaluated.
            </description>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Default value if the resulting value is null.
            </description>
            <name>default</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Determines whether characters &lt;,&gt;,&amp;,'," in the
                resulting string should be converted to their
                corresponding character entity codes. Default value is
                true.
            </description>
            <name>escapeXml</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>


    <tag>
    <description>
        Subtag of &lt;choose&gt; that follows &lt;when&gt; tags
        and runs only if all of the prior conditions evaluated to
        'false'
    </description>
    <name>otherwise</name>
    <tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
    <body-content>JSP</body-content>
  </tag>

  <tag>
    <description>
        Adds a parameter to a containing 'import' tag's URL.
    </description>
    <name>param</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.ParamTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Subtag of &lt;choose&gt; that follows &lt;when&gt; tags
            and runs only if all of the prior conditions evaluated to
            'false'
        </description>
        <name>otherwise</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
        <body-content>JSP</body-content>
    </tag>

    <tag>
        <description>
            Adds a parameter to a containing 'import' tag's URL.
        </description>
        <name>param</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.ParamTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the query string parameter.
            </description>
            <name>name</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Value of the parameter.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Redirects to a new URL.
    </description>
    <name>redirect</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.RedirectTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Redirects to a new URL.
        </description>
        <name>redirect</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.RedirectTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The URL of the resource to redirect to.
            </description>
            <name>url</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the context when redirecting to a relative URL
                resource that belongs to a foreign context.
            </description>
            <name>context</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Removes a scoped variable (from a particular scope, if specified).
    </description>
    <name>remove</name>
    <tag-class>org.apache.taglibs.standard.tag.common.core.RemoveTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Removes a scoped variable (from a particular scope, if specified).
        </description>
        <name>remove</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.RemoveTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                Name of the scoped variable to be removed.
            </description>
            <name>var</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Sets the result of an expression evaluation in a 'scope'
    </description>
    <name>set</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.SetTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Sets the result of an expression evaluation in a 'scope'
specified in the action. The type of the scoped variable is
whatever type the value expression evaluates to.
        </description>
        <name>set</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.SetTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable to hold the value
                specified in the action. The type of the scoped variable is
                whatever type the value expression evaluates to.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Expression to be evaluated.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <deferred-value>
                <type>java.lang.Object</type>
            </deferred-value>
        </attribute>
        <attribute>
            <description>
                Target object whose property will be set. Must evaluate to
                a JavaBeans object with setter property property, or to a
                java.util.Map object.
            </description>
            <name>target</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the property to be set in the target object.
            </description>
            <name>property</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Creates a URL with optional query parameters.
    </description>
    <name>url</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.UrlTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Creates a URL with optional query parameters.
processed url. The type of the scoped variable is
String.
        </description>
        <name>url</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.UrlTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                processed url. The type of the scoped variable is
                String.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                URL to be processed.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the context when specifying a relative URL
                resource that belongs to a foreign context.
            </description>
            <name>context</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
	Subtag of &lt;choose&gt; that includes its body if its
	condition evalutes to 'true'
    </description>
    <name>when</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.core.WhenTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Subtag of &lt;choose&gt; that includes its body if its
            condition evalutes to 'true'
        </description>
        <name>when</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.core.WhenTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The test condition that determines whether or not the
                body content should be processed.
            </description>
            <name>test</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>boolean</type>
        </attribute>
    </tag>

</taglib>




<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
        version="2.0">
    
  <description>JSTL 1.1 functions library</description>
  <display-name>JSTL functions</display-name>
  <tlib-version>1.1</tlib-version>
  <short-name>fn</short-name>
  <uri>http://java.sun.com/jsp/jstl/functions</uri>

    <description>JSTL 1.1 functions library</description>
    <display-name>JSTL functions</display-name>
    <tlib-version>1.1</tlib-version>
    <short-name>fn</short-name>
    <uri>http://java.sun.com/jsp/jstl/functions</uri>
    <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
    <function-signature>boolean contains(java.lang.String, java.lang.String)</function-signature>
    <example>
      &lt;c:if test="${fn:contains(name, searchString)}">
    </example>
  </function>

    <function>
        <description>
            Tests if an input string contains the specified substring.
        </description>
        <name>contains</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>boolean contains(java.lang.String, java.lang.String)</function-signature>
        <example>
            &lt;c:if test="${fn:contains(name, searchString)}">
        </example>
    </function>

    <function>
        <description>
            Tests if an input string contains the specified substring in a case insensitive way.
        </description>
        <name>containsIgnoreCase</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>boolean containsIgnoreCase(java.lang.String, java.lang.String)</function-signature>
        <example>
            &lt;c:if test="${fn:containsIgnoreCase(name, searchString)}">
        </example>
    </function>

    <function>
        <description>
            Tests if an input string ends with the specified suffix.
        </description>
        <name>endsWith</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>boolean endsWith(java.lang.String, java.lang.String)</function-signature>
        <example>
            &lt;c:if test="${fn:endsWith(filename, ".txt")}">
        </example>
    </function>

    <function>
        <description>
            Escapes characters that could be interpreted as XML markup.
        </description>
        <name>escapeXml</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>java.lang.String escapeXml(java.lang.String)</function-signature>
        <example>
            ${fn:escapeXml(param:info)}
        </example>
    </function>

    <function>
        <description>
            Returns the index withing a string of the first occurrence of a specified substring.
        </description>
        <name>indexOf</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>int indexOf(java.lang.String, java.lang.String)</function-signature>
        <example>
            ${fn:indexOf(name, "-")}
        </example>
    </function>

    <function>
        <description>
            Joins all elements of an array into a string.
        </description>
        <name>join</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>java.lang.String join(java.lang.String[], java.lang.String)</function-signature>
        <example>
            ${fn:join(array, ";")}
        </example>
    </function>

    <function>
        <description>
            Returns the number of items in a collection, or the number of characters in a string.
        </description>
        <name>length</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>int length(java.lang.Object)</function-signature>
        <example>
            You have ${fn:length(shoppingCart.products)} in your shopping cart.
        </example>
    </function>
  </function>

    <function>
        <description>
            Returns a string resulting from replacing in an input string all occurrences
            of a "before" string into an "after" substring.
        </description>
        <name>replace</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>java.lang.String replace(java.lang.String, java.lang.String, java.lang.String)
        </function-signature>
        <example>
            ${fn:replace(text, "-", "&#149;")}
        </example>
    </function>

    <function>
        <description>
            Splits a string into an array of substrings.
        </description>
        <name>split</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>java.lang.String[] split(java.lang.String, java.lang.String)</function-signature>
        <example>
            ${fn:split(customerNames, ";")}
        </example>
    </function>

    <function>
        <description>
            Tests if an input string starts with the specified prefix.
        </description>
        <name>startsWith</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>boolean startsWith(java.lang.String, java.lang.String)</function-signature>
        <example>
            &lt;c:if test="${fn:startsWith(product.id, "100-")}">
        </example>
    </function>

    <function>
        <description>
            Returns a subset of a string.
        </description>
        <name>substring</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>java.lang.String substring(java.lang.String, int, int)</function-signature>
        <example>
            P.O. Box: ${fn:substring(zip, 6, -1)}
        </example>
    </function>

    <function>
        <description>
            Returns a subset of a string following a specific substring.
        </description>
        <name>substringAfter</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>java.lang.String substringAfter(java.lang.String, java.lang.String)</function-signature>
        <example>
            P.O. Box: ${fn:substringAfter(zip, "-")}
        </example>
    </function>

    <function>
        <description>
            Returns a subset of a string before a specific substring.
        </description>
        <name>substringBefore</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>java.lang.String substringBefore(java.lang.String, java.lang.String)</function-signature>
        <example>
            Zip (without P.O. Box): ${fn:substringBefore(zip, "-")}
        </example>
    </function>

    <function>
        <description>
            Converts all of the characters of a string to lower case.
        </description>
        <name>toLowerCase</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>java.lang.String toLowerCase(java.lang.String)</function-signature>
        <example>
            Product name: ${fn.toLowerCase(product.name)}
        </example>
    </function>

    <function>
        <description>
            Converts all of the characters of a string to upper case.
        </description>
        <name>toUpperCase</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>java.lang.String toUpperCase(java.lang.String)</function-signature>
        <example>
            Product name: ${fn.UpperCase(product.name)}
        </example>
    </function>

    <function>
        <description>
            Removes white spaces from both ends of a string.
        </description>
        <name>trim</name>
        <function-class>org.apache.taglibs.standard.functions.Functions</function-class>
        <function-signature>java.lang.String trim(java.lang.String)</function-signature>
        <example>
            Name: ${fn.trim(name)}
        </example>
    </function>

</taglib>




<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
        version="2.0">
    <description>
        Restricts JSP pages to the JSTL tag libraries
    </description>
    <display-name>permittedTaglibs</display-name>
    <tlib-version>1.1</tlib-version>
    <short-name>permittedTaglibs</short-name>
    <uri>http://jakarta.apache.org/taglibs/standard/permittedTaglibs</uri>

    <validator>
        <validator-class>
            javax.servlet.jsp.jstl.tlv.PermittedTaglibsTLV
        </validator-class>
        <init-param>
            <description>
                Whitespace-separated list of taglib URIs to permit. This example
                TLD for the Standard Taglib allows only JSTL 'el' taglibs to be
                imported.
            </description>
            <param-name>permittedTaglibs</param-name>
            <param-value>
                http://java.sun.com/jsp/jstl/core
                http://java.sun.com/jsp/jstl/fmt
                http://java.sun.com/jsp/jstl/sql
                http://java.sun.com/jsp/jstl/xml
            </param-value>
        </init-param>
    </validator>
</taglib>




<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
        version="2.0">
  <description>
    Validates JSP pages to prohibit use of scripting elements.
  </description>
  <tlib-version>1.1</tlib-version>
  <short-name>scriptfree</short-name>
  <uri>http://jakarta.apache.org/taglibs/standard/scriptfree</uri>

  <validator>
    <description>
        Validates JSP pages to prohibit use of scripting elements.
    </description>
    <tlib-version>1.1</tlib-version>
    <short-name>scriptfree</short-name>
    <uri>http://jakarta.apache.org/taglibs/standard/scriptfree</uri>

    <validator>
        <description>
            Validates prohibitions against scripting elements.
        </description>
        <validator-class>
            javax.servlet.jsp.jstl.tlv.ScriptFreeTLV
        </validator-class>
        <init-param>
            <description>
                Controls whether or not declarations are considered valid.
            </description>
            <param-name>allowDeclarations</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <description>
                Controls whether or not scriptlets are considered valid.
            </description>
            <param-name>allowScriptlets</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <description>
                Controls whether or not top-level expressions are considered valid.
            </description>
            <param-name>allowExpressions</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <description>
                Controls whether or not expressions used to supply request-time
                attribute values are considered valid.
            </description>
            <param-name>allowRTExpressions</param-name>
            <param-value>false</param-value>
        </init-param>
    </validator>
</taglib>




<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
        version="2.0">
    
  <description>JSTL 1.1 i18n-capable formatting library</description>
  <display-name>JSTL fmt</display-name>
  <tlib-version>1.1</tlib-version>
  <short-name>fmt</short-name>
  <uri>http://java.sun.com/jsp/jstl/fmt</uri>

    <description>JSTL 1.1 i18n-capable formatting library</description>
    <display-name>JSTL fmt</display-name>
    <tlib-version>1.1</tlib-version>
    <short-name>fmt</short-name>
    <uri>http://java.sun.com/jsp/jstl/fmt</uri>
        org.apache.taglibs.standard.tlv.JstlFmtTLV
    </validator-class>
  </validator>

    <validator>
    <description>
        Sets the request character encoding
    </description>
    <name>requestEncoding</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.RequestEncodingTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Provides core validation features for JSTL tags.
decoding request parameters.
        </description>
        <validator-class>
            org.apache.taglibs.standard.tlv.JstlFmtTLV
        </validator-class>
    </validator>
  </tag>

    <tag>
    <description>
        Stores the given locale in the locale configuration variable
    </description>
    <name>setLocale</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetLocaleTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Sets the request character encoding
printable representation of a locale, which
must contain a two-letter (lower-case)
language code (as defined by ISO-639),
and may contain a two-letter (upper-case)
country code (as defined by ISO-3166).
Language and country codes must be
separated by hyphen (-) or underscore
(_).        
	</description>
        <name>value</name>
        <required>true</required>
        <rtexprvalue>true</rtexprvalue>
    </attribute>
    <attribute>
        <description>
Vendor- or browser-specific variant.
See the java.util.Locale javadocs for
more information on variants.
        </description>
        <name>requestEncoding</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.RequestEncodingTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                Name of character encoding to be applied when
                decoding request parameters.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <description>
            Stores the given locale in the locale configuration variable
        </description>
        <name>setLocale</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetLocaleTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                A String value is interpreted as the
                printable representation of a locale, which
                must contain a two-letter (lower-case)
                language code (as defined by ISO-639),
                and may contain a two-letter (upper-case)
                country code (as defined by ISO-3166).
                Language and country codes must be
                separated by hyphen (-) or underscore
                (_).
            </description>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Vendor- or browser-specific variant.
                See the java.util.Locale javadocs for
                more information on variants.
            </description>
            <name>variant</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope of the locale configuration variable.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Specifies the time zone for any time formatting or parsing actions
        nested in its body
    </description>
    <name>timeZone</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.TimeZoneTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Specifies the time zone for any time formatting or parsing actions
            nested in its body
IDs supported by the Java platform (such as
"America/Los_Angeles") or a custom time zone
ID (such as "GMT-8"). See
java.util.TimeZone for more information on
supported time zone formats.
        </description>
        <name>timeZone</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.TimeZoneTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The time zone. A String value is interpreted as
                a time zone ID. This may be one of the time zone
                IDs supported by the Java platform (such as
                "America/Los_Angeles") or a custom time zone
                ID (such as "GMT-8"). See
                java.util.TimeZone for more information on
                supported time zone formats.
            </description>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Stores the given time zone in the time zone configuration variable
    </description>
    <name>setTimeZone</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetTimeZoneTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Stores the given time zone in the time zone configuration variable
a time zone ID. This may be one of the time zone
IDs supported by the Java platform (such as
"America/Los_Angeles") or a custom time zone
ID (such as "GMT-8"). See java.util.TimeZone for
more information on supported time zone
formats.
        </description>
        <name>setTimeZone</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetTimeZoneTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                The time zone. A String value is interpreted as
                a time zone ID. This may be one of the time zone
                IDs supported by the Java platform (such as
                "America/Los_Angeles") or a custom time zone
                ID (such as "GMT-8"). See java.util.TimeZone for
                more information on supported time zone
                formats.
            </description>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable which
                stores the time zone of type
                java.util.TimeZone.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope of var or the time zone configuration
                variable.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Loads a resource bundle to be used by its tag body
    </description>
    <name>bundle</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.BundleTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Loads a resource bundle to be used by its tag body
fully-qualified resource name, which has the same
form as a fully-qualified class name, that is, it uses
"." as the package component separator and does not
have any file type (such as ".class" or ".properties")
suffix.
        </description>
        <name>bundle</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.BundleTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Resource bundle base name. This is the bundle's
                fully-qualified resource name, which has the same
                form as a fully-qualified class name, that is, it uses
                "." as the package component separator and does not
                have any file type (such as ".class" or ".properties")
                suffix.
            </description>
            <name>basename</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Prefix to be prepended to the value of the message
                key of any nested &lt;fmt:message&gt; action.
            </description>
            <name>prefix</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Loads a resource bundle and stores it in the named scoped variable or
        the bundle configuration variable
    </description>
    <name>setBundle</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetBundleTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Loads a resource bundle and stores it in the named scoped variable or
            the bundle configuration variable
form as a fully-qualified class name, that is, it uses
"." as the package component separator and does not
have any file type (such as ".class" or ".properties")
suffix.
        </description>
        <name>setBundle</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetBundleTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                Resource bundle base name. This is the bundle's
                fully-qualified resource name, which has the same
                form as a fully-qualified class name, that is, it uses
                "." as the package component separator and does not
                have any file type (such as ".class" or ".properties")
                suffix.
            </description>
            <name>basename</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable which stores
                the i18n localization context of type
                javax.servlet.jsp.jstl.fmt.LocalizationC
                ontext.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope of var or the localization context
                configuration variable.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Maps key to localized message and performs parametric replacement
    </description>
    <name>message</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.MessageTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Maps key to localized message and performs parametric replacement
        </description>
        <name>message</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.MessageTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Message key to be looked up.
            </description>
            <name>key</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Localization context in whose resource
                bundle the message key is looked up.
            </description>
            <name>bundle</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable
                which stores the localized message.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope of var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Supplies an argument for parametric replacement to a containing
        &lt;message&gt; tag
    </description>
    <name>param</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParamTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Supplies an argument for parametric replacement to a containing
            &lt;message&gt; tag
        </description>
        <name>param</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParamTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Argument used for parametric replacement.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Formats a numeric value as a number, currency, or percentage
    </description>
    <name>formatNumber</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatNumberTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Formats a numeric value as a number, currency, or percentage
        </description>
        <name>formatNumber</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatNumberTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Numeric value to be formatted.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Specifies whether the value is to be
                formatted as number, currency, or
                percentage.
            </description>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Custom formatting pattern.
            </description>
            <name>pattern</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                ISO 4217 currency code. Applied only
                when formatting currencies (i.e. if type is
                equal to "currency"); ignored otherwise.
            </description>
            <name>currencyCode</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Currency symbol. Applied only when
                formatting currencies (i.e. if type is equal
                to "currency"); ignored otherwise.
            </description>
            <name>currencySymbol</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Specifies whether the formatted output
                will contain any grouping separators.
            </description>
            <name>groupingUsed</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Maximum number of digits in the integer
                portion of the formatted output.
            </description>
            <name>maxIntegerDigits</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Minimum number of digits in the integer
                portion of the formatted output.
            </description>
            <name>minIntegerDigits</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Maximum number of digits in the
                fractional portion of the formatted output.
            </description>
            <name>maxFractionDigits</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Minimum number of digits in the
                fractional portion of the formatted output.
            </description>
            <name>minFractionDigits</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable
                which stores the formatted result as a
                String.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope of var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Parses the string representation of a number, currency, or percentage
    </description>
    <name>parseNumber</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseNumberTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Parses the string representation of a number, currency, or percentage
        </description>
        <name>parseNumber</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseNumberTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                String to be parsed.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Specifies whether the string in the value
                attribute should be parsed as a number,
                currency, or percentage.
            </description>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Custom formatting pattern that determines
                how the string in the value attribute is to be
                parsed.
            </description>
            <name>pattern</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Locale whose default formatting pattern (for
                numbers, currencies, or percentages,
                respectively) is to be used during the parse
                operation, or to which the pattern specified
                via the pattern attribute (if present) is
                applied.
            </description>
            <name>parseLocale</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Specifies whether just the integer portion of
                the given value should be parsed.
            </description>
            <name>integerOnly</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable which
                stores the parsed result (of type
                java.lang.Number).
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope of var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Formats a date and/or time using the supplied styles and pattern
    </description>
    <name>formatDate</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatDateTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Formats a date and/or time using the supplied styles and pattern
        </description>
        <name>formatDate</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatDateTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                Date and/or time to be formatted.
            </description>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Specifies whether the time, the date, or both
                the time and date components of the given
                date are to be formatted.
            </description>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Predefined formatting style for dates. Follows
                the semantics defined in class
                java.text.DateFormat. Applied only
                when formatting a date or both a date and
                time (i.e. if type is missing or is equal to
                "date" or "both"); ignored otherwise.
            </description>
            <name>dateStyle</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Predefined formatting style for times. Follows
                the semantics defined in class
                java.text.DateFormat. Applied only
                when formatting a time or both a date and
                time (i.e. if type is equal to "time" or "both");
                ignored otherwise.
            </description>
            <name>timeStyle</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Custom formatting style for dates and times.
            </description>
            <name>pattern</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Time zone in which to represent the formatted
                time.
            </description>
            <name>timeZone</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable which
                stores the formatted result as a String.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope of var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Parses the string representation of a date and/or time
    </description>
    <name>parseDate</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseDateTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Parses the string representation of a date and/or time
        </description>
        <name>parseDate</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseDateTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Date string to be parsed.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Specifies whether the date string in the
                value attribute is supposed to contain a
                time, a date, or both.
            </description>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Predefined formatting style for days
                which determines how the date
                component of the date string is to be
                parsed. Applied only when formatting a
                date or both a date and time (i.e. if type
                is missing or is equal to "date" or "both");
                ignored otherwise.
            </description>
            <name>dateStyle</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Predefined formatting styles for times
                which determines how the time
                component in the date string is to be
                parsed. Applied only when formatting a
                time or both a date and time (i.e. if type
                is equal to "time" or "both"); ignored
                otherwise.
            </description>
            <name>timeStyle</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Custom formatting pattern which
                determines how the date string is to be
                parsed.
            </description>
            <name>pattern</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Time zone in which to interpret any time
                information in the date string.
            </description>
            <name>timeZone</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Locale whose predefined formatting styles
                for dates and times are to be used during
                the parse operation, or to which the
                pattern specified via the pattern
                attribute (if present) is applied.
            </description>
            <name>parseLocale</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable in
                which the parsing result (of type
                java.util.Date) is stored.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope of var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

</taglib>




<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib
        PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
        "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
    <tlib-version>1.0</tlib-version>
    <jsp-version>1.2</jsp-version>
    <short-name>fmt_rt</short-name>
    <uri>http://java.sun.com/jstl/fmt_rt</uri>
    <display-name>JSTL fmt RT</display-name>
    <description>JSTL 1.0 i18n-capable formatting library</description>

    <validator>
        <validator-class>
            org.apache.taglibs.standard.tlv.JstlFmtTLV
        </validator-class>
        <description>
            Provides core validation features for JSTL tags.
        </description>
    </validator>

    <tag>
        <name>requestEncoding</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.RequestEncodingTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Sets the request character encoding
        </description>
        <attribute>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>setLocale</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetLocaleTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Stores the given locale in the locale configuration variable
        </description>
        <attribute>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>variant</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>timeZone</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.TimeZoneTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Specifies the time zone for any time formatting or parsing actions
            nested in its body
        </description>
        <attribute>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>setTimeZone</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetTimeZoneTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Stores the given time zone in the time zone configuration variable
        </description>
        <attribute>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>bundle</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.BundleTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Loads a resource bundle to be used by its tag body
        </description>
        <attribute>
            <name>basename</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>prefix</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>setBundle</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetBundleTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Loads a resource bundle and stores it in the named scoped variable or
            the bundle configuration variable
        </description>
        <attribute>
            <name>basename</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>message</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.MessageTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Maps key to localized message and performs parametric replacement
        </description>
        <attribute>
            <name>key</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>bundle</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>param</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParamTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Supplies an argument for parametric replacement to a containing
            &lt;message&gt; tag
        </description>
        <attribute>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>formatNumber</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatNumberTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Formats a numeric value as a number, currency, or percentage
        </description>
        <attribute>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>pattern</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>currencyCode</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>currencySymbol</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>groupingUsed</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>maxIntegerDigits</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>minIntegerDigits</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>maxFractionDigits</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>minFractionDigits</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>parseNumber</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseNumberTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Parses the string representation of a number, currency, or percentage
        </description>
        <attribute>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>pattern</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>parseLocale</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>integerOnly</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>formatDate</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatDateTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Formats a date and/or time using the supplied styles and pattern
        </description>
        <attribute>
            <name>value</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>dateStyle</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>timeStyle</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>pattern</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>timeZone</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>parseDate</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseDateTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Parses the string representation of a date and/or time
        </description>
        <attribute>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>type</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>dateStyle</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>timeStyle</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>pattern</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>timeZone</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>parseLocale</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

</taglib>




<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
        version="2.0">
    
  <description>JSTL 1.1 XML library</description>
  <display-name>JSTL XML</display-name>
  <tlib-version>1.1</tlib-version>
  <short-name>x</short-name>
  <uri>http://java.sun.com/jsp/jstl/xml</uri>

    <description>JSTL 1.1 XML library</description>
    <display-name>JSTL XML</display-name>
    <tlib-version>1.1</tlib-version>
    <short-name>x</short-name>
    <uri>http://java.sun.com/jsp/jstl/xml</uri>
	org.apache.taglibs.standard.tlv.JstlXmlTLV
    </validator-class>
  </validator>

    <validator>
    <description>
        Simple conditional tag that establishes a context for
        mutually exclusive conditional operations, marked by
        &lt;when&gt; and &lt;otherwise&gt;
    </description>
    <name>choose</name>
    <tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
    <body-content>JSP</body-content>
  </tag>

  <tag>
    <description>
	Like &lt;%= ... &gt;, but for XPath expressions.
    </description>
    <name>out</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.xml.ExprTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Provides validation features for JSTL XML tags.
        </description>
        <validator-class>
            org.apache.taglibs.standard.tlv.JstlXmlTLV
        </validator-class>
    </validator>

    <tag>
        <description>
            Simple conditional tag that establishes a context for
            mutually exclusive conditional operations, marked by
            &lt;when&gt; and &lt;otherwise&gt;
value is true.
        </description>
        <name>choose</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
        <body-content>JSP</body-content>
    </tag>
  </tag>

    <tag>
    <description>
        XML conditional tag, which evalutes its body if the
        supplied XPath expression evalutes to 'true' as a boolean
    </description>
    <name>if</name>
    <tag-class>org.apache.taglibs.standard.tag.common.xml.IfTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Like &lt;%= ... &gt;, but for XPath expressions.
body content should be processed.
        </description>
        <name>out</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.xml.ExprTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                XPath expression to be evaluated.
            </description>
            <name>select</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Determines whether characters &lt;,&gt;,&amp;,'," in the
                resulting string should be converted to their
                corresponding character entity codes. Default
                value is true.
            </description>
            <name>escapeXml</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <description>
            XML conditional tag, which evalutes its body if the
            supplied XPath expression evalutes to 'true' as a boolean
of the scoped variable is Boolean.
        </description>
        <name>if</name>
        <tag-class>org.apache.taglibs.standard.tag.common.xml.IfTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The test condition that tells whether or not the
                body content should be processed.
            </description>
            <name>select</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                resulting value of the test condition. The type
                of the scoped variable is Boolean.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <description>
            XML iteration tag.
        </description>
        <name>forEach</name>
        <tag-class>org.apache.taglibs.standard.tag.common.xml.ForEachTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                current item of the iteration. This scoped variable
                has nested visibility. Its type depends on the
                result of the XPath expression in the select
                attribute.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                XPath expression to be evaluated.
            </description>
            <name>select</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Iteration begins at the item located at the
                specified index. First item of the collection has
                index 0.
            </description>
            <name>begin</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Iteration ends at the item located at the specified
                index (inclusive).
            </description>
            <name>end</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Iteration will only process every step items of
                the collection, starting with the first one.
            </description>
            <name>step</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for the
                status of the iteration. Object exported is of type
                javax.servlet.jsp.jstl.core.LoopTagStatus. This scoped variable has nested visibility.
            </description>
            <name>varStatus</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
	XML iteration tag.
    </description>
    <name>forEach</name>
    <tag-class>org.apache.taglibs.standard.tag.common.xml.ForEachTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Subtag of &lt;choose&gt; that follows &lt;when&gt; tags
            and runs only if all of the prior conditions evaluated to
            'false'
result of the XPath expression in the select
attribute.
        </description>
        <name>otherwise</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
        <body-content>JSP</body-content>
    </tag>
    <attribute>
        <description>
XPath expression to be evaluated.
        </description>
	<name>select</name>
	<required>true</required>
	<rtexprvalue>false</rtexprvalue>
    </attribute>
    <attribute>
        <description>
Iteration begins at the item located at the
specified index. First item of the collection has
index 0.
        </description>
	<name>begin</name>
	<required>false</required>
	<rtexprvalue>true</rtexprvalue>
	<type>int</type>
    </attribute>
    <attribute>
        <description>
Iteration ends at the item located at the specified
index (inclusive).
        </description>
	<name>end</name>
	<required>false</required>
	<rtexprvalue>true</rtexprvalue>
	<type>int</type>
    </attribute>
    <attribute>
        <description>
Iteration will only process every step items of
the collection, starting with the first one.
        </description>
	<name>step</name>
	<required>false</required>
	<rtexprvalue>true</rtexprvalue>
	<type>int</type>
    </attribute>
    <attribute>
        <description>
Name of the exported scoped variable for the
status of the iteration. Object exported is of type
javax.servlet.jsp.jstl.core.LoopTagStatus. This scoped variable has nested visibility.
        </description>
	<name>varStatus</name>
	<required>false</required>
	<rtexprvalue>false</rtexprvalue>
    </attribute>
  </tag>

    <tag>
    <description>
	Subtag of &lt;choose&gt; that follows &lt;when&gt; tags
	and runs only if all of the prior conditions evaluated to
	'false'
    </description>
    <name>otherwise</name>
    <tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
    <body-content>JSP</body-content>
  </tag>

  <tag>
    <description>
        Adds a parameter to a containing 'transform' tag's Transformer
    </description>
    <name>param</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.xml.ParamTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Adds a parameter to a containing 'transform' tag's Transformer
        </description>
        <name>param</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.xml.ParamTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the transformation parameter.
            </description>
            <name>name</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Value of the parameter.
            </description>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
	Parses XML content from 'source' attribute or 'body'
    </description>
    <name>parse</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.xml.ParseTag</tag-class>
    <tei-class>org.apache.taglibs.standard.tei.XmlParseTEI</tei-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Parses XML content from 'source' attribute or 'body'
the parsed XML document. The type of the
scoped variable is implementation
dependent.
        </description>
        <name>parse</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.xml.ParseTag</tag-class>
        <tei-class>org.apache.taglibs.standard.tei.XmlParseTEI</tei-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable for
                the parsed XML document. The type of the
                scoped variable is implementation
                dependent.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Name of the exported scoped variable for
                the parsed XML document. The type of the
                scoped variable is
                org.w3c.dom.Document.
            </description>
            <name>varDom</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for varDom.
            </description>
            <name>scopeDom</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Deprecated. Use attribute 'doc' instead.
            </description>
            <name>xml</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Source XML document to be parsed.
            </description>
            <name>doc</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                The system identifier (URI) for parsing the
                XML document.
            </description>
            <name>systemId</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Filter to be applied to the source
                document.
            </description>
            <name>filter</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
	Saves the result of an XPath expression evaluation in a 'scope'
    </description>
    <name>set</name>
    <tag-class>org.apache.taglibs.standard.tag.common.xml.SetTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <description>
            Saves the result of an XPath expression evaluation in a 'scope'
the value specified in the action. The type of the
scoped variable is whatever type the select
expression evaluates to.
        </description>
        <name>set</name>
        <tag-class>org.apache.taglibs.standard.tag.common.xml.SetTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>
                Name of the exported scoped variable to hold
                the value specified in the action. The type of the
                scoped variable is whatever type the select
                expression evaluates to.
            </description>
            <name>var</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                XPath expression to be evaluated.
            </description>
            <name>select</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
	Conducts a transformation given a source XML document
	and an XSLT stylesheet
    </description>
    <name>transform</name>
    <tag-class>org.apache.taglibs.standard.tag.rt.xml.TransformTag</tag-class>
    <tei-class>org.apache.taglibs.standard.tei.XmlTransformTEI</tei-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Conducts a transformation given a source XML document
            and an XSLT stylesheet
transformed XML
document. The type of the
scoped variable is
org.w3c.dom.Document.
        </description>
        <name>transform</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.xml.TransformTag</tag-class>
        <tei-class>org.apache.taglibs.standard.tei.XmlTransformTEI</tei-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                Name of the exported
                scoped variable for the
                transformed XML
                document. The type of the
                scoped variable is
                org.w3c.dom.Document.
            </description>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Scope for var.
            </description>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Result
                Object that captures or
                processes the transformation
                result.
            </description>
            <name>result</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Deprecated. Use attribute
                'doc' instead.
            </description>
            <name>xml</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Source XML document to be
                transformed. (If exported by
                &lt;x:set&gt;, it must correspond
                to a well-formed XML
                document, not a partial
                document.)
            </description>
            <name>doc</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                Deprecated. Use attribute
                'docSystemId' instead.
            </description>
            <name>xmlSystemId</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                The system identifier (URI)
                for parsing the XML
                document.
            </description>
            <name>docSystemId</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                javax.xml.transform.Source
                Transformation stylesheet as
                a String, Reader, or
                Source object.
            </description>
            <name>xslt</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <description>
                The system identifier (URI)
                for parsing the XSLT
                stylesheet.
            </description>
            <name>xsltSystemId</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
    <description>
        Subtag of &lt;choose&gt; that includes its body if its
        expression evalutes to 'true'
    </description>
    <name>when</name>
    <tag-class>org.apache.taglibs.standard.tag.common.xml.WhenTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <description>
            Subtag of &lt;choose&gt; that includes its body if its
            expression evalutes to 'true'
processed
        </description>
        <name>when</name>
        <tag-class>org.apache.taglibs.standard.tag.common.xml.WhenTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The test condition that tells whether or
                not the body content should be
                processed
            </description>
            <name>select</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

</taglib>




<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib
        PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
        "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
    <tlib-version>1.0</tlib-version>
    <jsp-version>1.2</jsp-version>
    <short-name>x_rt</short-name>
    <uri>http://java.sun.com/jstl/xml_rt</uri>
    <display-name>JSTL XML RT</display-name>
    <description>JSTL 1.0 XML library</description>

    <validator>
        <validator-class>
            org.apache.taglibs.standard.tlv.JstlXmlTLV
        </validator-class>
        <description>
            Provides validation features for JSTL XML tags.
        </description>
    </validator>

    <tag>
        <name>choose</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Simple conditional tag that establishes a context for
            mutually exclusive conditional operations, marked by
            &lt;when&gt; and &lt;otherwise&gt;
        </description>
    </tag>

    <tag>
        <name>out</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.xml.ExprTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Like &lt;%= ... &gt;, but for XPath expressions.
        </description>
        <attribute>
            <name>select</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>escapeXml</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>if</name>
        <tag-class>org.apache.taglibs.standard.tag.common.xml.IfTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            XML conditional tag, which evalutes its body if the
            supplied XPath expression evalutes to 'true' as a boolean
        </description>
        <attribute>
            <name>select</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>forEach</name>
        <tag-class>org.apache.taglibs.standard.tag.common.xml.ForEachTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            XML iteration tag.
        </description>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>select</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>otherwise</name>
        <tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Subtag of &lt;choose&gt; that follows &lt;when&gt; tags
            and runs only if all of the prior conditions evaluated to
            'false'
        </description>
    </tag>

    <tag>
        <name>param</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.xml.ParamTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Adds a parameter to a containing 'transform' tag's Transformer
        </description>
        <attribute>
            <name>name</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>value</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>parse</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.xml.ParseTag</tag-class>
        <tei-class>org.apache.taglibs.standard.tei.XmlParseTEI</tei-class>
        <body-content>JSP</body-content>
        <description>
            Parses XML content from 'source' attribute or 'body'
        </description>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>varDom</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scopeDom</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>xml</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>systemId</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>filter</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>set</name>
        <tag-class>org.apache.taglibs.standard.tag.common.xml.SetTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Saves the result of an XPath expression evaluation in a 'scope'
        </description>
        <attribute>
            <name>var</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>select</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>transform</name>
        <tag-class>org.apache.taglibs.standard.tag.rt.xml.TransformTag</tag-class>
        <tei-class>org.apache.taglibs.standard.tei.XmlTransformTEI</tei-class>
        <body-content>JSP</body-content>
        <description>
            Conducts a transformation given a source XML document
            and an XSLT stylesheet
        </description>
        <attribute>
            <name>var</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>scope</name>
            <required>false</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
        <attribute>
            <name>result</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>xml</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>xmlSystemId</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>xslt</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>xsltSystemId</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>when</name>
        <tag-class>org.apache.taglibs.standard.tag.common.xml.WhenTag</tag-class>
        <body-content>JSP</body-content>
        <description>
            Subtag of &lt;choose&gt; that includes its body if its
            expression evalutes to 'true'
        </description>
        <attribute>
            <name>select</name>
            <required>true</required>
            <rtexprvalue>false</rtexprvalue>
        </attribute>
    </tag>

</taglib>




    Enable Cactus tests
-->
<project
        xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.apache.taglibs</groupId>
        <artifactId>taglibs-parent</artifactId>
        <version>1-SNAPSHOT</version>
    </parent>

    <artifactId>taglibs-standard-impl</artifactId>
    <version>1.2-SNAPSHOT</version>
    <packaging>bundle</packaging>

    <name>Apache Standard Taglib - JSTL Implementation</name>

    <inceptionYear>2001</inceptionYear>
    <description>
        An implementation of the JSP Standard Tag Library (JSTL).
    </description>

    <url>http://tomcat.apache.org/taglibs/standard/</url>

    <scm>
        <connection>scm:svn:http://svn.apache.org/repos/asf/tomcat/taglibs/standard/trunk/impl</connection>
        <developerConnection>scm:svn:https://svn.apache.org/repos/asf/tomcat/taglibs/standard/trunk/impl
        </developerConnection>
        <url>http://svn.apache.org/viewvc/tomcat/taglibs/standard/trunk/impl</url>
    </scm>

    <developers>
        <developer>
            <name>Pierre Delisle</name>
        </developer>
        <developer>
            <name>Shawn Bayern</name>
        </developer>
        <developer>
            <name>Nathan Abramson</name>
        </developer>
        <developer>
            <name>Hans Bergsten</name>
        </developer>
        <developer>
            <name>Scott Hasse</name>
        </developer>
        <developer>
            <name>Justyna Horwat</name>
        </developer>
        <developer>
            <name>Mark Kolb</name>
        </developer>
        <developer>
            <name>Jan Luehe</name>
        </developer>
        <developer>
            <name>Glenn Nielsen</name>
        </developer>
        <developer>
            <name>Dmitri Plotnikov</name>
        </developer>
        <developer>
            <name>Felipe Leme</name>
        </developer>
        <developer>
            <name>Henri Yandell</name>
        </developer>
        <developer>
            <name>Bjorn Townsend</name>
        </developer>
    </developers>

    <contributors>
        <contributor>
            <name>Robert Goff</name>
        </contributor>
    </contributors>

    <dependencies>
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-spec</artifactId>
            <version>1.2-SNAPSHOT</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>el-api</artifactId>
            <version>1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>xalan</groupId>
            <artifactId>xalan</artifactId>
            <version>2.7.1</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.easymock</groupId>
            <artifactId>easymock</artifactId>
            <version>3.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-bundle-plugin</artifactId>
                <configuration>
                    <excludeDependencies>true</excludeDependencies>
                    <instructions>
                        <Export-Package>*;version="1.2"</Export-Package>
                        <Import-Package>org.apache.x*;resolution:=optional,*</Import-Package>
                    </instructions>
                </configuration>
            </plugin>
        </plugins>
    </build>
  
  <reporting>
    <plugins>
      <plugin>
        <artifactId>maven-pmd-plugin</artifactId>
        <version>2.3</version>
        <configuration>
          <targetJdk>${maven.compiler.target}</targetJdk>
        </configuration>
        <reportSets>
          <reportSet>
            <reports>
              <report>pmd</report>
              <report>cpd</report>
            </reports>
          </reportSet>
        </reportSets>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>taglist-maven-plugin</artifactId>
        <version>2.4</version>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>javancss-maven-plugin</artifactId>
        <version>2.0</version>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>findbugs-maven-plugin</artifactId>
        <version>1.2</version>
        <configuration>
          <threshold>Normal</threshold>
          <effort>Default</effort>
<!--          <excludeFilterFile>${basedir}/findbugs-exclude-filter.xml</excludeFilterFile> -->
       </configuration>
      </plugin>
    </plugins>
  </reporting>

    <reporting>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>jxr-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <artifactId>maven-pmd-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <targetJdk>${maven.compiler.target}</targetJdk>
                </configuration>
                <reportSets>
                    <reportSet>
                        <reports>
                            <report>pmd</report>
                            <report>cpd</report>
                        </reports>
                    </reportSet>
                </reportSets>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>taglist-maven-plugin</artifactId>
                <version>2.4</version>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>javancss-maven-plugin</artifactId>
                <version>2.0</version>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>findbugs-maven-plugin</artifactId>
                <version>1.2</version>
                <configuration>
                    <threshold>Normal</threshold>
                    <effort>Default</effort>
                    <!--          <excludeFilterFile>${basedir}/findbugs-exclude-filter.xml</excludeFilterFile> -->
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-checkstyle-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <configLocation>checkstyle.xml</configLocation>
                </configuration>
            </plugin>
        </plugins>
    </reporting>


</project>

Return to bug 50279

Lines 16-32 Link Here

(-)src/test/java/org/apache/taglibs/standard/util/EscapeXMLTest.java (-7 / +8 lines)
16	*/	16	*/
17	package org.apache.taglibs.standard.util;	17	package org.apache.taglibs.standard.util;
18		18
		19	import java.io.IOException;
		20	import java.io.Reader;
		21	import java.io.StringReader;
		22
		23	import javax.servlet.jsp.JspWriter;
		24
19	import org.junit.Assert;	25	import org.junit.Assert;
20	import org.junit.Before;	26	import org.junit.Before;
21	import org.junit.Test;	27	import org.junit.Test;
22		28
23	import javax.servlet.jsp.JspWriter;	29	import static org.apache.taglibs.standard.util.EscapeXML.emit;
24		30	import static org.apache.taglibs.standard.util.EscapeXML.escape;
25	import java.io.IOException;
26	import java.io.Reader;
27	import java.io.StringReader;
28
29	import static org.apache.taglibs.standard.util.EscapeXML.*;
30	import static org.easymock.EasyMock.createMock;	31	import static org.easymock.EasyMock.createMock;
31	import static org.easymock.EasyMock.eq;	32	import static org.easymock.EasyMock.eq;
32	import static org.easymock.EasyMock.expect;	33	import static org.easymock.EasyMock.expect;

Lines 27-44 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/common/xml/UnresolvableException.java (-2 / +4 lines)
27	/**	27	/**
28	* Create an UnresolvableException object that holds	28	* Create an UnresolvableException object that holds
29	* an error message.	29	* an error message.
		30	*
30	* @param message The error message.	31	* @param message The error message.
31	*/	32	*/
32	public UnresolvableException(String message) {	33	public UnresolvableException(String message) {
33	super(message);	34	super(message);
34	}	35	}
35		36
36	/**	37	/**
37	* Create an UnresolvableException object that holds	38	* Create an UnresolvableException object that holds
38	* an error message, and another exception	39	* an error message, and another exception
39	* that caused this exception.	40	* that caused this exception.
		41	*
40	* @param message The error message.	42	* @param message The error message.
41	* @param e The exception that caused this exception.	43	* @param e The exception that caused this exception.
42	*/	44	*/
43	public UnresolvableException(String message, Exception e) {	45	public UnresolvableException(String message, Exception e) {
44	super(message, e);	46	super(message, e);

Lines 39-45 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/common/xml/JSTLXPathAPI.java (-118 / +111 lines)
39	* created for each evaluation. A faster way is to precompile the	39	* created for each evaluation. A faster way is to precompile the
40	* XPaths using the low-level API, and then just use the XPaths	40	* XPaths using the low-level API, and then just use the XPaths
41	* over and over.	41	* over and over.
42	*	42	* <p/>
43	* NOTE: In particular, each call to this method will create a new	43	* NOTE: In particular, each call to this method will create a new
44	* XPathContext, a new DTMManager... and thus a new DTM. That's very	44	* XPathContext, a new DTMManager... and thus a new DTM. That's very
45	* safe, since it guarantees that you're always processing against a	45	* safe, since it guarantees that you're always processing against a
Lines 49-246 Link Here
49	* methods.	49	* methods.
50	*	50	*
51	* @see <a href="http://www.w3.org/TR/xpath">XPath Specification</a>	51	* @see <a href="http://www.w3.org/TR/xpath">XPath Specification</a>
52	*
53	*/	52	*/
54	public class JSTLXPathAPI extends XPathAPI {	53	public class JSTLXPathAPI extends XPathAPI {
55	/**	54	/**
56	* Use an XPath string to select a single node.	55	* Use an XPath string to select a single node.
57	* XPath namespace prefixes are resolved using the prefixResolver.	56	* XPath namespace prefixes are resolved using the prefixResolver.
58	*	57	*
59	* @param contextNode The node to start searching from.	58	* @param contextNode The node to start searching from.
60	* @param str A valid XPath string.	59	* @param str A valid XPath string.
61	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.	60	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
62	* @return The first node found that matches the XPath, or null.	61	* @return The first node found that matches the XPath, or null.
63	*
64	* @throws JspTagException	62	* @throws JspTagException
65	*/	63	*/
66	public static Node selectSingleNode(	64	public static Node selectSingleNode(
67	Node contextNode, String str, PrefixResolver prefixResolver)	65	Node contextNode, String str, PrefixResolver prefixResolver)
68	throws JspTagException {	66	throws JspTagException {
69		67
70	// Have the XObject return its result as a NodeSetDTM.	68	// Have the XObject return its result as a NodeSetDTM.
71	NodeIterator nl = selectNodeIterator(contextNode, str, prefixResolver);	69	NodeIterator nl = selectNodeIterator(contextNode, str, prefixResolver);
72		70
73	// Return the first node, or null	71	// Return the first node, or null
74	return nl.nextNode();	72	return nl.nextNode();
75	}	73	}
76		74
77	/**	75	/**
78	* Use an XPath string to select a single node.	76	* Use an XPath string to select a single node.
79	* XPath namespace prefixes are resolved using the prefixResolver.	77	* XPath namespace prefixes are resolved using the prefixResolver.
80	*	78	*
81	* @param contextNode The node to start searching from.	79	* @param contextNode The node to start searching from.
82	* @param str A valid XPath string.	80	* @param str A valid XPath string.
83	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.	81	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
84	* @return The first node found that matches the XPath, or null.	82	* @return The first node found that matches the XPath, or null.
85	*
86	* @throws JspTagException	83	* @throws JspTagException
87	*/	84	*/
88	public static Node selectSingleNode(	85	public static Node selectSingleNode(
89	Node contextNode, String str, PrefixResolver prefixResolver,	86	Node contextNode, String str, PrefixResolver prefixResolver,
90	XPathContext xpathSupport ) throws JspTagException {	87	XPathContext xpathSupport) throws JspTagException {
91		88
92	// Have the XObject return its result as a NodeSetDTM.	89	// Have the XObject return its result as a NodeSetDTM.
93	NodeIterator nl = selectNodeIterator(contextNode, str, prefixResolver, xpathSupport);	90	NodeIterator nl = selectNodeIterator(contextNode, str, prefixResolver, xpathSupport);
94		91
95	// Return the first node, or null	92	// Return the first node, or null
96	return nl.nextNode();	93	return nl.nextNode();
97	}	94	}
98		95
99	/**	96	/**
100	* Use an XPath string to select a nodelist.	97	* Use an XPath string to select a nodelist.
101	* XPath namespace prefixes are resolved using PrefixResolver.	98	* XPath namespace prefixes are resolved using PrefixResolver.
102	*	99	*
103	* @param contextNode The node to start searching from.	100	* @param contextNode The node to start searching from.
104	* @param str A valid XPath string.	101	* @param str A valid XPath string.
105	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.	102	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
106	* @return A NodeIterator, should never be null.	103	* @return A NodeIterator, should never be null.
107	*
108	* @throws JspTagException	104	* @throws JspTagException
109	*/	105	*/
110	public static NodeIterator selectNodeIterator(	106	public static NodeIterator selectNodeIterator(
111	Node contextNode, String str, PrefixResolver prefixResolver)	107	Node contextNode, String str, PrefixResolver prefixResolver)
112	throws JspTagException {	108	throws JspTagException {
113		109
114	// Execute the XPath, and have it return the result	110	// Execute the XPath, and have it return the result
115	XObject list = eval(contextNode, str, prefixResolver, null);	111	XObject list = eval(contextNode, str, prefixResolver, null);
116		112
117	// Have the XObject return its result as a NodeSetDTM.	113	// Have the XObject return its result as a NodeSetDTM.
118	return getNodeIterator(list);	114	return getNodeIterator(list);
119	}	115	}
120		116
121	/**	117	/**
122	* Use an XPath string to select a nodelist.	118	* Use an XPath string to select a nodelist.
123	* XPath namespace prefixes are resolved using PrefixResolver.	119	* XPath namespace prefixes are resolved using PrefixResolver.
124	*	120	*
125	* @param contextNode The node to start searching from.	121	* @param contextNode The node to start searching from.
126	* @param str A valid XPath string.	122	* @param str A valid XPath string.
127	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.	123	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
128	* @return A NodeIterator, should never be null.	124	* @return A NodeIterator, should never be null.
129	*
130	* @throws JspTagException	125	* @throws JspTagException
131	*/	126	*/
132	public static NodeIterator selectNodeIterator(	127	public static NodeIterator selectNodeIterator(
133	Node contextNode, String str, PrefixResolver prefixResolver,	128	Node contextNode, String str, PrefixResolver prefixResolver,
134	XPathContext xpathSupport ) throws JspTagException {	129	XPathContext xpathSupport) throws JspTagException {
135		130
136	// Execute the XPath, and have it return the result	131	// Execute the XPath, and have it return the result
137	XObject list = eval(contextNode, str, prefixResolver, xpathSupport);	132	XObject list = eval(contextNode, str, prefixResolver, xpathSupport);
138		133
139	// Have the XObject return its result as a NodeSetDTM.	134	// Have the XObject return its result as a NodeSetDTM.
140	return getNodeIterator(list);	135	return getNodeIterator(list);
141	}	136	}
142		137
143	/**	138	/**
144	* Use an XPath string to select a nodelist.	139	* Use an XPath string to select a nodelist.
145	* XPath namespace prefixes are resolved using the prefixResolver.	140	* XPath namespace prefixes are resolved using the prefixResolver.
146	*	141	*
147	* @param contextNode The node to start searching from.	142	* @param contextNode The node to start searching from.
148	* @param str A valid XPath string.	143	* @param str A valid XPath string.
149	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.	144	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
150	* @return A NodeIterator, should never be null.	145	* @return A NodeIterator, should never be null.
151	*
152	* @throws JspTagException	146	* @throws JspTagException
153	*/	147	*/
154	private static NodeList selectNodeList(	148	private static NodeList selectNodeList(
155	Node contextNode, String str, PrefixResolver prefixResolver)	149	Node contextNode, String str, PrefixResolver prefixResolver)
156	throws JspTagException {	150	throws JspTagException {
157	// Execute the XPath, and have it return the result	151	// Execute the XPath, and have it return the result
158	XObject list = eval(contextNode, str, prefixResolver, null);	152	XObject list = eval(contextNode, str, prefixResolver, null);
159		153
160	// Return a NodeList.	154	// Return a NodeList.
161	return getNodeList(list);	155	return getNodeList(list);
162	}	156	}
163		157
164	/**	158	/**
165	* Use an XPath string to select a nodelist.	159	* Use an XPath string to select a nodelist.
166	* XPath namespace prefixes are resolved using the prefixResolver.	160	* XPath namespace prefixes are resolved using the prefixResolver.
167	*	161	*
168	* @param contextNode The node to start searching from.	162	* @param contextNode The node to start searching from.
169	* @param str A valid XPath string.	163	* @param str A valid XPath string.
170	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.	164	* @param prefixResolver The PrefixResolver using which prefixes in the XPath will be resolved to namespaces.
171	* @return A NodeIterator, should never be null.	165	* @return A NodeIterator, should never be null.
172	*
173	* @throws JspTagException	166	* @throws JspTagException
174	*/	167	*/
175	public static NodeList selectNodeList(	168	public static NodeList selectNodeList(
176	Node contextNode, String str, PrefixResolver prefixResolver,	169	Node contextNode, String str, PrefixResolver prefixResolver,
177	XPathContext xpathSupport )	170	XPathContext xpathSupport)
178	throws JspTagException	171	throws JspTagException {
179	{
180	// Execute the XPath, and have it return the result	172	// Execute the XPath, and have it return the result
181	XObject list = eval(contextNode, str, prefixResolver, xpathSupport);	173	XObject list = eval(contextNode, str, prefixResolver, xpathSupport);
182		174
183	// Return a NodeList.	175	// Return a NodeList.
184	return getNodeList(list);	176	return getNodeList(list);
185	}	177	}
186		178
187	/**	179	/**
188	* Returns a NodeIterator from an XObject.	180	* Returns a NodeIterator from an XObject.
189	* @param list The XObject from which a NodeIterator is returned.	181	*
190	* @return A NodeIterator, should never be null.	182	* @param list The XObject from which a NodeIterator is returned.
191	* @throws JspTagException	183	* @return A NodeIterator, should never be null.
		184	* @throws JspTagException
192	*/	185	*/
193	private static NodeIterator getNodeIterator(XObject list)	186	private static NodeIterator getNodeIterator(XObject list)
194	throws JspTagException {	187	throws JspTagException {
195	try {	188	try {
196	return list.nodeset();	189	return list.nodeset();
197	} catch (TransformerException ex) {	190	} catch (TransformerException ex) {
198	throw new JspTagException(	191	throw new JspTagException(
199	Resources.getMessage("XPATH_ERROR_XOBJECT", ex.toString()), ex);	192	Resources.getMessage("XPATH_ERROR_XOBJECT", ex.toString()), ex);
200	}	193	}
201	}	194	}
202		195
203	/**	196	/**
204	* Returns a NodeList from an XObject.	197	* Returns a NodeList from an XObject.
205	* @param list The XObject from which a NodeList is returned.	198	*
206	* @return A NodeList, should never be null.	199	* @param list The XObject from which a NodeList is returned.
207	* @throws JspTagException	200	* @return A NodeList, should never be null.
		201	* @throws JspTagException
208	*/	202	*/
209	static NodeList getNodeList(XObject list)	203	static NodeList getNodeList(XObject list)
210	throws JspTagException {	204	throws JspTagException {
211	try {	205	try {
212	return list.nodelist();	206	return list.nodelist();
213	} catch (TransformerException ex) {	207	} catch (TransformerException ex) {
214	throw new JspTagException(	208	throw new JspTagException(
215	Resources.getMessage("XPATH_ERROR_XOBJECT", ex.toString()), ex);	209	Resources.getMessage("XPATH_ERROR_XOBJECT", ex.toString()), ex);
216	}	210	}
217	}	211	}
218		212
219	/**	213	/**
220	* Evaluate XPath string to an XObject.	214	* Evaluate XPath string to an XObject.
221	* XPath namespace prefixes are resolved from the namespaceNode.	215	* XPath namespace prefixes are resolved from the namespaceNode.
222	* The implementation of this is a little slow, since it creates	216	* The implementation of this is a little slow, since it creates
223	* a number of objects each time it is called. This could be optimized	217	* a number of objects each time it is called. This could be optimized
224	* to keep the same objects around, but then thread-safety issues would arise.	218	* to keep the same objects around, but then thread-safety issues would arise.
225	*	219	*
226	* @param contextNode The node to start searching from.	220	* @param contextNode The node to start searching from.
227	* @param str A valid XPath string.	221	* @param str A valid XPath string.
228	* @param xpathSupport The node from which prefixes in the XPath will be resolved to namespaces.	222	* @param xpathSupport The node from which prefixes in the XPath will be resolved to namespaces.
229	* @param prefixResolver Will be called if the parser encounters namespace	223	* @param prefixResolver Will be called if the parser encounters namespace
230	* prefixes, to resolve the prefixes to URLs.	224	* prefixes, to resolve the prefixes to URLs.
231	* @return An XObject, which can be used to obtain a string, number, nodelist, etc, should never be null.	225	* @return An XObject, which can be used to obtain a string, number, nodelist, etc, should never be null.
232	* @see org.apache.xpath.objects.XObject
233	* @see org.apache.xpath.objects.XNull
234	* @see org.apache.xpath.objects.XBoolean
235	* @see org.apache.xpath.objects.XNumber
236	* @see org.apache.xpath.objects.XString
237	* @see org.apache.xpath.objects.XRTreeFrag
238	*
239	* @throws JspTagException	226	* @throws JspTagException
		227	* @see org.apache.xpath.objects.XObject
		228	* @see org.apache.xpath.objects.XNull
		229	* @see org.apache.xpath.objects.XBoolean
		230	* @see org.apache.xpath.objects.XNumber
		231	* @see org.apache.xpath.objects.XString
		232	* @see org.apache.xpath.objects.XRTreeFrag
240	*/	233	*/
241	public static XObject eval(	234	public static XObject eval(
242	Node contextNode, String str, PrefixResolver prefixResolver,	235	Node contextNode, String str, PrefixResolver prefixResolver,
243	XPathContext xpathSupport) throws JspTagException {	236	XPathContext xpathSupport) throws JspTagException {
244	//System.out.println("eval of XPathContext params: contextNode:str(xpath)"+	237	//System.out.println("eval of XPathContext params: contextNode:str(xpath)"+
245	// ":prefixResolver:xpathSupport => " + contextNode + ":" + str + ":" +	238	// ":prefixResolver:xpathSupport => " + contextNode + ":" + str + ":" +
246	// prefixResolver + ":" + xpathSupport );	239	// prefixResolver + ":" + xpathSupport );
Lines 248-254 Link Here
248	if (xpathSupport == null) {	241	if (xpathSupport == null) {
249	return eval(contextNode, str, prefixResolver);	242	return eval(contextNode, str, prefixResolver);
250	}	243	}
251		244
252	// Since we don't have a XML Parser involved here, install some default support	245	// Since we don't have a XML Parser involved here, install some default support
253	// for things like namespaces, etc.	246	// for things like namespaces, etc.
254	// (Changed from: XPathContext xpathSupport = new XPathContext();	247	// (Changed from: XPathContext xpathSupport = new XPathContext();
Lines 256-280 Link Here
256	// XPathContext should be done away with.)	249	// XPathContext should be done away with.)
257	// Create the XPath object.	250	// Create the XPath object.
258	XPath xpath = new XPath(str, null, prefixResolver, XPath.SELECT, null);	251	XPath xpath = new XPath(str, null, prefixResolver, XPath.SELECT, null);
259		252
260	// Execute the XPath, and have it return the result	253	// Execute the XPath, and have it return the result
261	int ctxtNode = xpathSupport.getDTMHandleFromNode(contextNode);	254	int ctxtNode = xpathSupport.getDTMHandleFromNode(contextNode);
262		255
263	// System.out.println("Context Node id ( after getDTMHandlerFromNode) => " + ctxtNode );	256	// System.out.println("Context Node id ( after getDTMHandlerFromNode) => " + ctxtNode );
264	XObject xobj = xpath.execute(xpathSupport, ctxtNode, prefixResolver);	257	XObject xobj = xpath.execute(xpathSupport, ctxtNode, prefixResolver);
265	return xobj;	258	return xobj;
266	} catch (TransformerException ex) {	259	} catch (TransformerException ex) {
267	throw new JspTagException(	260	throw new JspTagException(
268	Resources.getMessage("XPATH_ERROR_EVALUATING_EXPR", str, ex.toString()), ex);	261	Resources.getMessage("XPATH_ERROR_EVALUATING_EXPR", str, ex.toString()), ex);
269	} catch (IllegalArgumentException ex) {	262	} catch (IllegalArgumentException ex) {
270	throw new JspTagException(	263	throw new JspTagException(
271	Resources.getMessage("XPATH_ILLEGAL_ARG_EVALUATING_EXPR", str, ex.toString()), ex);	264	Resources.getMessage("XPATH_ILLEGAL_ARG_EVALUATING_EXPR", str, ex.toString()), ex);
272	}	265	}
273	}	266	}
274		267
275	public static XObject eval(	268	public static XObject eval(
276	Node contextNode, String str, PrefixResolver prefixResolver,	269	Node contextNode, String str, PrefixResolver prefixResolver,
277	XPathContext xpathSupport, Vector varQNames) throws JspTagException {	270	XPathContext xpathSupport, Vector varQNames) throws JspTagException {
278	//p("***************** eval ");	271	//p("***************** eval ");
279	//p( "contextNode => " + contextNode );	272	//p( "contextNode => " + contextNode );
280	//p( "XPath str => " + str );	273	//p( "XPath str => " + str );
Lines 283-304 Link Here
283	//p( "Var QNames => " + varQNames );	276	//p( "Var QNames => " + varQNames );
284	//p( "Global Var Size => " + varQNames.size() );	277	//p( "Global Var Size => " + varQNames.size() );
285	try {	278	try {
286	XPath xpath = new XPath(str, null, prefixResolver, XPath.SELECT, null);	279	XPath xpath = new XPath(str, null, prefixResolver, XPath.SELECT, null);
287	xpath.fixupVariables( varQNames, varQNames.size());	280	xpath.fixupVariables(varQNames, varQNames.size());
288	// Execute the XPath, and have it return the result	281	// Execute the XPath, and have it return the result
289	int ctxtNode = xpathSupport.getDTMHandleFromNode(contextNode);	282	int ctxtNode = xpathSupport.getDTMHandleFromNode(contextNode);
290	// System.out.println("Context Node id ( after getDTMHandlerFromNode) => " + ctxtNode );	283	// System.out.println("Context Node id ( after getDTMHandlerFromNode) => " + ctxtNode );
291	return xpath.execute(xpathSupport, ctxtNode, prefixResolver);	284	return xpath.execute(xpathSupport, ctxtNode, prefixResolver);
292	} catch (TransformerException ex) {	285	} catch (TransformerException ex) {
293	throw new JspTagException(	286	throw new JspTagException(
294	Resources.getMessage("XPATH_ERROR_EVALUATING_EXPR", str, ex.toString()), ex);	287	Resources.getMessage("XPATH_ERROR_EVALUATING_EXPR", str, ex.toString()), ex);
295	} catch (IllegalArgumentException ex) {	288	} catch (IllegalArgumentException ex) {
296	throw new JspTagException(	289	throw new JspTagException(
297	Resources.getMessage("XPATH_ILLEGAL_ARG_EVALUATING_EXPR", str, ex.toString()), ex);	290	Resources.getMessage("XPATH_ILLEGAL_ARG_EVALUATING_EXPR", str, ex.toString()), ex);
298	}	291	}
299	}	292	}
300		293
301	private static void p(String s) {	294	private static void p(String s) {
302	System.out.println("[JSTLXPathAPI] " + s);	295	System.out.println("[JSTLXPathAPI] " + s);
303	}	296	}
304	}	297	}

Lines 28-154 Link Here

(-)src/main/java/org/apache/taglibs/standard/tag/common/xml/JSTLPrefixResolver.java (-100 / +91 lines)
28	* can be used to perform prefix-to-namespace lookup	28	* can be used to perform prefix-to-namespace lookup
29	* for the XPath object.	29	* for the XPath object.
30	*/	30	*/
31	public class JSTLPrefixResolver implements PrefixResolver	31	public class JSTLPrefixResolver implements PrefixResolver {
32	{
33		32
34	/**	33	/**
35	* The context to resolve the prefix from, if the context	34	* The context to resolve the prefix from, if the context
36	* is not given. */	35	* is not given.
		36	*/
37		37
38	HashMap namespaces;	38	HashMap namespaces;
39		39
40	/**	40	/**
41	* The URI for the XML namespace.	41	* The URI for the XML namespace.
42	* (Duplicate of that found in org.apache.xpath.XPathContext). */	42	* (Duplicate of that found in org.apache.xpath.XPathContext).
43		43	*/
44	public static final String S_XMLNAMESPACEURI =
45	"http://www.w3.org/XML/1998/namespace";
46		44
47	/**	45	public static final String S_XMLNAMESPACEURI =
48	* No-arg constructor which would create empty HashMap of namespaces	46	"http://www.w3.org/XML/1998/namespace";
49	*/
50	public JSTLPrefixResolver()
51	{
52	namespaces = new HashMap();
53	}
54		47
55	public JSTLPrefixResolver( HashMap nses )	48	/**
56	{	49	* No-arg constructor which would create empty HashMap of namespaces
57	namespaces = nses;	50	*/
58	}	51	public JSTLPrefixResolver() {
		52	namespaces = new HashMap();
		53	}
59		54
60	/**	55	public JSTLPrefixResolver(HashMap nses) {
61	* Given a namespace, get the corresponding prefix. This assumes that	56	namespaces = nses;
62	* the PrevixResolver hold's it's own namespace context, or is a namespace	57	}
63	* context itself.
64	* @param prefix Prefix to resolve.
65	* @return Namespace that prefix resolves to, or null if prefix
66	* is not bound.
67	*/
68	public String getNamespaceForPrefix(String prefix)
69	{
70	return (String)namespaces.get(prefix);
71	}
72		58
73	/**	59	/**
74	* Given a prefix and a Context Node, get the corresponding namespace.	60	* Given a namespace, get the corresponding prefix. This assumes that
75	* Warning: This will not work correctly if namespaceContext	61	* the PrevixResolver hold's it's own namespace context, or is a namespace
76	* is an attribute node.	62	* context itself.
77	* @param prefix Prefix to resolve.	63	*
78	* @param namespaceContext Node from which to start searching for a	64	* @param prefix Prefix to resolve.
79	* xmlns attribute that binds a prefix to a namespace.	65	* @return Namespace that prefix resolves to, or null if prefix
80	* @return Namespace that prefix resolves to, or null if prefix	66	* is not bound.
81	* is not bound.	67	*/
82	*/	68	public String getNamespaceForPrefix(String prefix) {
83	public String getNamespaceForPrefix(String prefix,	69	return (String) namespaces.get(prefix);
84	org.w3c.dom.Node namespaceContext)	70	}
85	{
86		71
87	Node parent = namespaceContext;	72	/**
88	String namespace = null;	73	* Given a prefix and a Context Node, get the corresponding namespace.
		74	* Warning: This will not work correctly if namespaceContext
		75	* is an attribute node.
		76	*
		77	* @param prefix Prefix to resolve.
		78	* @param namespaceContext Node from which to start searching for a
		79	* xmlns attribute that binds a prefix to a namespace.
		80	* @return Namespace that prefix resolves to, or null if prefix
		81	* is not bound.
		82	*/
		83	public String getNamespaceForPrefix(String prefix,
		84	org.w3c.dom.Node namespaceContext) {
89		85
90	if (prefix.equals("xml"))	86	Node parent = namespaceContext;
91	{	87	String namespace = null;
92	namespace = S_XMLNAMESPACEURI;
93	}
94	else
95	{
96	int type;
97		88
98	while ((null != parent) && (null == namespace)	89	if (prefix.equals("xml")) {
99	&& (((type = parent.getNodeType()) == Node.ELEMENT_NODE)	90	namespace = S_XMLNAMESPACEURI;
100	\|\| (type == Node.ENTITY_REFERENCE_NODE)))	91	} else {
101	{	92	int type;
102	if (type == Node.ELEMENT_NODE)
103	{
104	NamedNodeMap nnm = parent.getAttributes();
105		93
106	for (int i = 0; i < nnm.getLength(); i++)	94	while ((null != parent) && (null == namespace)
107	{	95	&& (((type = parent.getNodeType()) == Node.ELEMENT_NODE)
108	Node attr = nnm.item(i);	96	\|\| (type == Node.ENTITY_REFERENCE_NODE))) {
109	String aname = attr.getNodeName();	97	if (type == Node.ELEMENT_NODE) {
110	boolean isPrefix = aname.startsWith("xmlns:");	98	NamedNodeMap nnm = parent.getAttributes();
111		99
112	if (isPrefix \|\| aname.equals("xmlns"))	100	for (int i = 0; i < nnm.getLength(); i++) {
113	{	101	Node attr = nnm.item(i);
114	int index = aname.indexOf(':');	102	String aname = attr.getNodeName();
115	String p = isPrefix ? aname.substring(index + 1) : "";	103	boolean isPrefix = aname.startsWith("xmlns:");
116		104
117	if (p.equals(prefix))	105	if (isPrefix \|\| aname.equals("xmlns")) {
118	{	106	int index = aname.indexOf(':');
119	namespace = attr.getNodeValue();	107	String p = isPrefix ? aname.substring(index + 1) : "";
120		108
121	break;	109	if (p.equals(prefix)) {
122	}	110	namespace = attr.getNodeValue();
		111
		112	break;
		113	}
		114	}
		115	}
		116	}
		117
		118	parent = parent.getParentNode();
123	}	119	}
124	}
125	}	120	}
126		121
127	parent = parent.getParentNode();	122	return namespace;
128	}
129	}	123	}
130		124
131	return namespace;	125	/**
132	}	126	* Return the base identifier.
		127	*
		128	* @return null
		129	*/
		130	public String getBaseIdentifier() {
		131	return null;
		132	}
133		133
134	/**	134	/**
135	* Return the base identifier.	135	* @see PrefixResolver#handlesNullPrefixes()
136	*	136	*/
137	* @return null	137	public boolean handlesNullPrefixes() {
138	*/	138	return false;
139	public String getBaseIdentifier()	139	}
140	{
141	return null;
142	}
143		140
144	/**	141	public void addNamespace(String prefix, String uri) {
145	* @see PrefixResolver#handlesNullPrefixes() */	142	namespaces.put(prefix, uri);
146	public boolean handlesNullPrefixes() {	143	}
147	return false;
148	}
149		144
150	public void addNamespace ( String prefix, String uri ) {
151	namespaces.put( prefix, uri );
152	}
153
154	}	145	}

Lines 1-188 Link Here

(-)src/main/resources/META-INF/sql-1_0-rt.tld (-177 / +177 lines)
1	<?xml version="1.0" encoding="ISO-8859-1" ?>	1	<?xml version="1.0" encoding="ISO-8859-1" ?>
2	<!DOCTYPE taglib	2	<!DOCTYPE taglib
3	PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"	3	PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
4	"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">	4	"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
5	<taglib>	5	<taglib>
6	<tlib-version>1.0</tlib-version>	6	<tlib-version>1.0</tlib-version>
7	<jsp-version>1.2</jsp-version>	7	<jsp-version>1.2</jsp-version>
8	<short-name>sql_rt</short-name>	8	<short-name>sql_rt</short-name>
9	<uri>http://java.sun.com/jstl/sql_rt</uri>	9	<uri>http://java.sun.com/jstl/sql_rt</uri>
10	<display-name>JSTL sql RT</display-name>	10	<display-name>JSTL sql RT</display-name>
11	<description>JSTL 1.0 sql library</description>	11	<description>JSTL 1.0 sql library</description>
12		12
13	<validator>	13	<validator>
14	<validator-class>	14	<validator-class>
15	org.apache.taglibs.standard.tlv.JstlSqlTLV	15	org.apache.taglibs.standard.tlv.JstlSqlTLV
16	</validator-class>	16	</validator-class>
17	<description>	17	<description>
18	Provides core validation features for JSTL tags.	18	Provides core validation features for JSTL tags.
19	</description>	19	</description>
20	</validator>	20	</validator>
21		21
22	<tag>	22	<tag>
23	<name>transaction</name>	23	<name>transaction</name>
24	<tag-class>org.apache.taglibs.standard.tag.rt.sql.TransactionTag</tag-class>	24	<tag-class>org.apache.taglibs.standard.tag.rt.sql.TransactionTag</tag-class>
25	<body-content>JSP</body-content>	25	<body-content>JSP</body-content>
26	<description>	26	<description>
27	Provides nested database action elements with a shared Connection,	27	Provides nested database action elements with a shared Connection,
28	set up to execute all statements as one transaction.	28	set up to execute all statements as one transaction.
29	</description>	29	</description>
30	<attribute>	30	<attribute>
31	<name>dataSource</name>	31	<name>dataSource</name>
32	<required>false</required>	32	<required>false</required>
33	<rtexprvalue>true</rtexprvalue>	33	<rtexprvalue>true</rtexprvalue>
34	</attribute>	34	</attribute>
35	<attribute>	35	<attribute>
36	<name>isolation</name>	36	<name>isolation</name>
37	<required>false</required>	37	<required>false</required>
38	<rtexprvalue>true</rtexprvalue>	38	<rtexprvalue>true</rtexprvalue>
39	</attribute>	39	</attribute>
40	</tag>	40	</tag>
41		41
42	<tag>	42	<tag>
43	<name>query</name>	43	<name>query</name>
44	<tag-class>org.apache.taglibs.standard.tag.rt.sql.QueryTag</tag-class>	44	<tag-class>org.apache.taglibs.standard.tag.rt.sql.QueryTag</tag-class>
45	<body-content>JSP</body-content>	45	<body-content>JSP</body-content>
46	<description>	46	<description>
47	Executes the SQL query defined in its body or through the	47	Executes the SQL query defined in its body or through the
48	sql attribute.	48	sql attribute.
49	</description>	49	</description>
50	<attribute>	50	<attribute>
51	<name>var</name>	51	<name>var</name>
52	<required>true</required>	52	<required>true</required>
53	<rtexprvalue>false</rtexprvalue>	53	<rtexprvalue>false</rtexprvalue>
54	</attribute>	54	</attribute>
55	<attribute>	55	<attribute>
56	<name>scope</name>	56	<name>scope</name>
57	<required>false</required>	57	<required>false</required>
58	<rtexprvalue>false</rtexprvalue>	58	<rtexprvalue>false</rtexprvalue>
59	</attribute>	59	</attribute>
60	<attribute>	60	<attribute>
61	<name>sql</name>	61	<name>sql</name>
62	<required>false</required>	62	<required>false</required>
63	<rtexprvalue>true</rtexprvalue>	63	<rtexprvalue>true</rtexprvalue>
64	</attribute>	64	</attribute>
65	<attribute>	65	<attribute>
66	<name>dataSource</name>	66	<name>dataSource</name>
67	<required>false</required>	67	<required>false</required>
68	<rtexprvalue>true</rtexprvalue>	68	<rtexprvalue>true</rtexprvalue>
69	</attribute>	69	</attribute>
70	<attribute>	70	<attribute>
71	<name>startRow</name>	71	<name>startRow</name>
72	<required>false</required>	72	<required>false</required>
73	<rtexprvalue>true</rtexprvalue>	73	<rtexprvalue>true</rtexprvalue>
74	</attribute>	74	</attribute>
75	<attribute>	75	<attribute>
76	<name>maxRows</name>	76	<name>maxRows</name>
77	<required>false</required>	77	<required>false</required>
78	<rtexprvalue>true</rtexprvalue>	78	<rtexprvalue>true</rtexprvalue>
79	</attribute>	79	</attribute>
80	</tag>	80	</tag>
81		81
82	<tag>	82	<tag>
83	<name>update</name>	83	<name>update</name>
84	<tag-class>org.apache.taglibs.standard.tag.rt.sql.UpdateTag</tag-class>	84	<tag-class>org.apache.taglibs.standard.tag.rt.sql.UpdateTag</tag-class>
85	<body-content>JSP</body-content>	85	<body-content>JSP</body-content>
86	<description>	86	<description>
87	Executes the SQL update defined in its body or through the	87	Executes the SQL update defined in its body or through the
88	sql attribute.	88	sql attribute.
89	</description>	89	</description>
90	<attribute>	90	<attribute>
91	<name>var</name>	91	<name>var</name>
92	<required>false</required>	92	<required>false</required>
93	<rtexprvalue>false</rtexprvalue>	93	<rtexprvalue>false</rtexprvalue>
94	</attribute>	94	</attribute>
95	<attribute>	95	<attribute>
96	<name>scope</name>	96	<name>scope</name>
97	<required>false</required>	97	<required>false</required>
98	<rtexprvalue>false</rtexprvalue>	98	<rtexprvalue>false</rtexprvalue>
99	</attribute>	99	</attribute>
100	<attribute>	100	<attribute>
101	<name>sql</name>	101	<name>sql</name>
102	<required>false</required>	102	<required>false</required>
103	<rtexprvalue>true</rtexprvalue>	103	<rtexprvalue>true</rtexprvalue>
104	</attribute>	104	</attribute>
105	<attribute>	105	<attribute>
106	<name>dataSource</name>	106	<name>dataSource</name>
107	<required>false</required>	107	<required>false</required>
108	<rtexprvalue>true</rtexprvalue>	108	<rtexprvalue>true</rtexprvalue>
109	</attribute>	109	</attribute>
110	</tag>	110	</tag>
111		111
112	<tag>	112	<tag>
113	<name>param</name>	113	<name>param</name>
114	<tag-class>org.apache.taglibs.standard.tag.rt.sql.ParamTag</tag-class>	114	<tag-class>org.apache.taglibs.standard.tag.rt.sql.ParamTag</tag-class>
115	<body-content>JSP</body-content>	115	<body-content>JSP</body-content>
116	<description>	116	<description>
117	Sets a parameter in an SQL statement to the specified value.	117	Sets a parameter in an SQL statement to the specified value.
118	</description>	118	</description>
119	<attribute>	119	<attribute>
120	<name>value</name>	120	<name>value</name>
121	<required>false</required>	121	<required>false</required>
122	<rtexprvalue>true</rtexprvalue>	122	<rtexprvalue>true</rtexprvalue>
123	</attribute>	123	</attribute>
124	</tag>	124	</tag>
125		125
126	<tag>	126	<tag>
127	<name>dateParam</name>	127	<name>dateParam</name>
128	<tag-class>org.apache.taglibs.standard.tag.rt.sql.DateParamTag</tag-class>	128	<tag-class>org.apache.taglibs.standard.tag.rt.sql.DateParamTag</tag-class>
129	<body-content>empty</body-content>	129	<body-content>empty</body-content>
130	<description>	130	<description>
131	Sets a parameter in an SQL statement to the specified java.util.Date value.	131	Sets a parameter in an SQL statement to the specified java.util.Date value.
132	</description>	132	</description>
133	<attribute>	133	<attribute>
134	<name>value</name>	134	<name>value</name>
135	<required>true</required>	135	<required>true</required>
136	<rtexprvalue>true</rtexprvalue>	136	<rtexprvalue>true</rtexprvalue>
137	</attribute>	137	</attribute>
138	<attribute>	138	<attribute>
139	<name>type</name>	139	<name>type</name>
140	<required>false</required>	140	<required>false</required>
141	<rtexprvalue>true</rtexprvalue>	141	<rtexprvalue>true</rtexprvalue>
142	</attribute>	142	</attribute>
143	</tag>	143	</tag>
144		144
145	<tag>	145	<tag>
146	<name>setDataSource</name>	146	<name>setDataSource</name>
147	<tag-class>org.apache.taglibs.standard.tag.rt.sql.SetDataSourceTag</tag-class>	147	<tag-class>org.apache.taglibs.standard.tag.rt.sql.SetDataSourceTag</tag-class>
148	<body-content>empty</body-content>	148	<body-content>empty</body-content>
149	<description>	149	<description>
150	Creates a simple DataSource suitable only for prototyping.	150	Creates a simple DataSource suitable only for prototyping.
151	</description>	151	</description>
152	<attribute>	152	<attribute>
153	<name>var</name>	153	<name>var</name>
154	<required>false</required>	154	<required>false</required>
155	<rtexprvalue>false</rtexprvalue>	155	<rtexprvalue>false</rtexprvalue>
156	</attribute>	156	</attribute>
157	<attribute>	157	<attribute>
158	<name>scope</name>	158	<name>scope</name>
159	<required>false</required>	159	<required>false</required>
160	<rtexprvalue>false</rtexprvalue>	160	<rtexprvalue>false</rtexprvalue>
161	</attribute>	161	</attribute>
162	<attribute>	162	<attribute>
163	<name>dataSource</name>	163	<name>dataSource</name>
164	<required>false</required>	164	<required>false</required>
165	<rtexprvalue>true</rtexprvalue>	165	<rtexprvalue>true</rtexprvalue>
166	</attribute>	166	</attribute>
167	<attribute>	167	<attribute>
168	<name>driver</name>	168	<name>driver</name>
169	<required>false</required>	169	<required>false</required>
170	<rtexprvalue>true</rtexprvalue>	170	<rtexprvalue>true</rtexprvalue>
171	</attribute>	171	</attribute>
172	<attribute>	172	<attribute>
173	<name>url</name>	173	<name>url</name>
174	<required>false</required>	174	<required>false</required>
175	<rtexprvalue>true</rtexprvalue>	175	<rtexprvalue>true</rtexprvalue>
176	</attribute>	176	</attribute>
177	<attribute>	177	<attribute>
178	<name>user</name>	178	<name>user</name>
179	<required>false</required>	179	<required>false</required>
180	<rtexprvalue>true</rtexprvalue>	180	<rtexprvalue>true</rtexprvalue>
181	</attribute>	181	</attribute>
182	<attribute>	182	<attribute>
183	<name>password</name>	183	<name>password</name>
184	<required>false</required>	184	<required>false</required>
185	<rtexprvalue>true</rtexprvalue>	185	<rtexprvalue>true</rtexprvalue>
186	</attribute>	186	</attribute>
187	</tag>	187	</tag>
188	</taglib>	188	</taglib>

Lines 1-289 Link Here

(-)src/main/resources/META-INF/sql.tld (-264 / +264 lines)
1	<?xml version="1.0" encoding="UTF-8" ?>	1	<?xml version="1.0" encoding="UTF-8" ?>
2		2
3	<taglib xmlns="http://java.sun.com/xml/ns/j2ee"	3	<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
4	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"	4	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"	5	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
6	version="2.0">	6	version="2.0">
7
8	<description>JSTL 1.1 sql library</description>
9	<display-name>JSTL sql</display-name>
10	<tlib-version>1.1</tlib-version>
11	<short-name>sql</short-name>
12	<uri>http://java.sun.com/jsp/jstl/sql</uri>
13		7
14	<validator>	8	<description>JSTL 1.1 sql library</description>
15	<description>	9	<display-name>JSTL sql</display-name>
16	Provides core validation features for JSTL tags.	10	<tlib-version>1.1</tlib-version>
17	</description>	11	<short-name>sql</short-name>
18	<validator-class>	12	<uri>http://java.sun.com/jsp/jstl/sql</uri>
19	org.apache.taglibs.standard.tlv.JstlSqlTLV
20	</validator-class>
21	</validator>
22		13
23	<tag>	14	<validator>
24	<description>
25	Provides nested database action elements with a shared Connection,
26	set up to execute all statements as one transaction.
27	</description>
28	<name>transaction</name>
29	<tag-class>org.apache.taglibs.standard.tag.rt.sql.TransactionTag</tag-class>
30	<body-content>JSP</body-content>
31	<attribute>
32	<description>	15	<description>
33	DataSource associated with the database to access. A	16	Provides core validation features for JSTL tags.
34	String value represents a relative path to a JNDI
35	resource or the parameters for the JDBC
36	DriverManager facility.
37	</description>	17	</description>
38	<name>dataSource</name>	18	<validator-class>
39	<required>false</required>	19	org.apache.taglibs.standard.tlv.JstlSqlTLV
40	<rtexprvalue>true</rtexprvalue>	20	</validator-class>
41	</attribute>	21	</validator>
42	<attribute>	22
		23	<tag>
43	<description>	24	<description>
44	Transaction isolation level. If not specified, it is the	25	Provides nested database action elements with a shared Connection,
45	isolation level the DataSource has been configured	26	set up to execute all statements as one transaction.
46	with.
47	</description>	27	</description>
48	<name>isolation</name>	28	<name>transaction</name>
49	<required>false</required>	29	<tag-class>org.apache.taglibs.standard.tag.rt.sql.TransactionTag</tag-class>
50	<rtexprvalue>true</rtexprvalue>	30	<body-content>JSP</body-content>
51	</attribute>	31	<attribute>
52	</tag>	32	<description>
		33	DataSource associated with the database to access. A
		34	String value represents a relative path to a JNDI
		35	resource or the parameters for the JDBC
		36	DriverManager facility.
		37	</description>
		38	<name>dataSource</name>
		39	<required>false</required>
		40	<rtexprvalue>true</rtexprvalue>
		41	</attribute>
		42	<attribute>
		43	<description>
		44	Transaction isolation level. If not specified, it is the
		45	isolation level the DataSource has been configured
		46	with.
		47	</description>
		48	<name>isolation</name>
		49	<required>false</required>
		50	<rtexprvalue>true</rtexprvalue>
		51	</attribute>
		52	</tag>
53		53
54	<tag>	54	<tag>
55	<description>
56	Executes the SQL query defined in its body or through the
57	sql attribute.
58	</description>
59	<name>query</name>
60	<tag-class>org.apache.taglibs.standard.tag.rt.sql.QueryTag</tag-class>
61	<body-content>JSP</body-content>
62	<attribute>
63	<description>	55	<description>
64	Name of the exported scoped variable for the	56	Executes the SQL query defined in its body or through the
65	query result. The type of the scoped variable is	57	sql attribute.
66	javax.servlet.jsp.jstl.sql.
67	Result (see Chapter 16 "Java APIs").
68	</description>	58	</description>
69	<name>var</name>	59	<name>query</name>
70	<required>true</required>	60	<tag-class>org.apache.taglibs.standard.tag.rt.sql.QueryTag</tag-class>
71	<rtexprvalue>false</rtexprvalue>	61	<body-content>JSP</body-content>
72	</attribute>	62	<attribute>
73	<attribute>	63	<description>
74	<description>	64	Name of the exported scoped variable for the
75	Scope of var.	65	query result. The type of the scoped variable is
76	</description>	66	javax.servlet.jsp.jstl.sql.
77	<name>scope</name>	67	Result (see Chapter 16 "Java APIs").
78	<required>false</required>	68	</description>
79	<rtexprvalue>false</rtexprvalue>	69	<name>var</name>
80	</attribute>	70	<required>true</required>
81	<attribute>	71	<rtexprvalue>false</rtexprvalue>
82	<description>	72	</attribute>
83	SQL query statement.	73	<attribute>
84	</description>	74	<description>
85	<name>sql</name>	75	Scope of var.
86	<required>false</required>	76	</description>
87	<rtexprvalue>true</rtexprvalue>	77	<name>scope</name>
88	</attribute>	78	<required>false</required>
89	<attribute>	79	<rtexprvalue>false</rtexprvalue>
90	<description>	80	</attribute>
91	Data source associated with the database to	81	<attribute>
92	query. A String value represents a relative path	82	<description>
93	to a JNDI resource or the parameters for the	83	SQL query statement.
94	DriverManager class.	84	</description>
95	</description>	85	<name>sql</name>
96	<name>dataSource</name>	86	<required>false</required>
97	<required>false</required>	87	<rtexprvalue>true</rtexprvalue>
98	<rtexprvalue>true</rtexprvalue>	88	</attribute>
99	</attribute>	89	<attribute>
100	<attribute>	90	<description>
101	<description>	91	Data source associated with the database to
102	The returned Result object includes the rows	92	query. A String value represents a relative path
103	starting at the specified index. The first row of	93	to a JNDI resource or the parameters for the
104	the original query result set is at index 0. If not	94	DriverManager class.
105	specified, rows are included starting from the	95	</description>
106	first row at index 0.	96	<name>dataSource</name>
107	</description>	97	<required>false</required>
108	<name>startRow</name>	98	<rtexprvalue>true</rtexprvalue>
109	<required>false</required>	99	</attribute>
110	<rtexprvalue>true</rtexprvalue>	100	<attribute>
111	</attribute>	101	<description>
112	<attribute>	102	The returned Result object includes the rows
113	<description>	103	starting at the specified index. The first row of
114	The maximum number of rows to be included in	104	the original query result set is at index 0. If not
115	the query result. If not specified, or set to -1, no	105	specified, rows are included starting from the
116	limit on the maximum number of rows is	106	first row at index 0.
117	enforced.	107	</description>
118	</description>	108	<name>startRow</name>
119	<name>maxRows</name>	109	<required>false</required>
120	<required>false</required>	110	<rtexprvalue>true</rtexprvalue>
121	<rtexprvalue>true</rtexprvalue>	111	</attribute>
122	</attribute>	112	<attribute>
123	</tag>	113	<description>
		114	The maximum number of rows to be included in
		115	the query result. If not specified, or set to -1, no
		116	limit on the maximum number of rows is
		117	enforced.
		118	</description>
		119	<name>maxRows</name>
		120	<required>false</required>
		121	<rtexprvalue>true</rtexprvalue>
		122	</attribute>
		123	</tag>
124		124
125	<tag>	125	<tag>
126	<description>
127	Executes the SQL update defined in its body or through the
128	sql attribute.
129	</description>
130	<name>update</name>
131	<tag-class>org.apache.taglibs.standard.tag.rt.sql.UpdateTag</tag-class>
132	<body-content>JSP</body-content>
133	<attribute>
134	<description>	126	<description>
135	Name of the exported scoped variable for the result	127	Executes the SQL update defined in its body or through the
136	of the database update. The type of the scoped	128	sql attribute.
137	variable is java.lang.Integer.
138	</description>	129	</description>
139	<name>var</name>	130	<name>update</name>
140	<required>false</required>	131	<tag-class>org.apache.taglibs.standard.tag.rt.sql.UpdateTag</tag-class>
141	<rtexprvalue>false</rtexprvalue>	132	<body-content>JSP</body-content>
142	</attribute>	133	<attribute>
143	<attribute>	134	<description>
144	<description>	135	Name of the exported scoped variable for the result
145	Scope of var.	136	of the database update. The type of the scoped
146	</description>	137	variable is java.lang.Integer.
147	<name>scope</name>	138	</description>
148	<required>false</required>	139	<name>var</name>
149	<rtexprvalue>false</rtexprvalue>	140	<required>false</required>
150	</attribute>	141	<rtexprvalue>false</rtexprvalue>
151	<attribute>	142	</attribute>
152	<description>	143	<attribute>
153	SQL update statement.	144	<description>
154	</description>	145	Scope of var.
155	<name>sql</name>	146	</description>
156	<required>false</required>	147	<name>scope</name>
157	<rtexprvalue>true</rtexprvalue>	148	<required>false</required>
158	</attribute>	149	<rtexprvalue>false</rtexprvalue>
159	<attribute>	150	</attribute>
160	<description>	151	<attribute>
161	Data source associated with the database to update.	152	<description>
162	A String value represents a relative path to a JNDI	153	SQL update statement.
163	resource or the parameters for the JDBC	154	</description>
164	DriverManager class.	155	<name>sql</name>
165	</description>	156	<required>false</required>
166	<name>dataSource</name>	157	<rtexprvalue>true</rtexprvalue>
167	<required>false</required>	158	</attribute>
168	<rtexprvalue>true</rtexprvalue>	159	<attribute>
169	</attribute>	160	<description>
170	</tag>	161	Data source associated with the database to update.
		162	A String value represents a relative path to a JNDI
		163	resource or the parameters for the JDBC
		164	DriverManager class.
		165	</description>
		166	<name>dataSource</name>
		167	<required>false</required>
		168	<rtexprvalue>true</rtexprvalue>
		169	</attribute>
		170	</tag>
171		171
172	<tag>	172	<tag>
173	<description>
174	Sets a parameter in an SQL statement to the specified value.
175	</description>
176	<name>param</name>
177	<tag-class>org.apache.taglibs.standard.tag.rt.sql.ParamTag</tag-class>
178	<body-content>JSP</body-content>
179	<attribute>
180	<description>	173	<description>
181	Parameter value.	174	Sets a parameter in an SQL statement to the specified value.
182	</description>	175	</description>
183	<name>value</name>	176	<name>param</name>
184	<required>false</required>	177	<tag-class>org.apache.taglibs.standard.tag.rt.sql.ParamTag</tag-class>
185	<rtexprvalue>true</rtexprvalue>	178	<body-content>JSP</body-content>
186	</attribute>	179	<attribute>
187	</tag>	180	<description>
		181	Parameter value.
		182	</description>
		183	<name>value</name>
		184	<required>false</required>
		185	<rtexprvalue>true</rtexprvalue>
		186	</attribute>
		187	</tag>
188		188
189	<tag>	189	<tag>
190	<description>
191	Sets a parameter in an SQL statement to the specified java.util.Date value.
192	</description>
193	<name>dateParam</name>
194	<tag-class>org.apache.taglibs.standard.tag.rt.sql.DateParamTag</tag-class>
195	<body-content>empty</body-content>
196	<attribute>
197	<description>	190	<description>
198	Parameter value for DATE, TIME, or	191	Sets a parameter in an SQL statement to the specified java.util.Date value.
199	TIMESTAMP column in a database table.
200	</description>	192	</description>
201	<name>value</name>	193	<name>dateParam</name>
202	<required>true</required>	194	<tag-class>org.apache.taglibs.standard.tag.rt.sql.DateParamTag</tag-class>
203	<rtexprvalue>true</rtexprvalue>	195	<body-content>empty</body-content>
204	</attribute>	196	<attribute>
205	<attribute>	197	<description>
206	<description>	198	Parameter value for DATE, TIME, or
207	One of "date", "time" or "timestamp".	199	TIMESTAMP column in a database table.
208	</description>	200	</description>
209	<name>type</name>	201	<name>value</name>
210	<required>false</required>	202	<required>true</required>
211	<rtexprvalue>true</rtexprvalue>	203	<rtexprvalue>true</rtexprvalue>
212	</attribute>	204	</attribute>
213	</tag>	205	<attribute>
		206	<description>
		207	One of "date", "time" or "timestamp".
		208	</description>
		209	<name>type</name>
		210	<required>false</required>
		211	<rtexprvalue>true</rtexprvalue>
		212	</attribute>
		213	</tag>
214		214
215	<tag>	215	<tag>
216	<description>
217	Creates a simple DataSource suitable only for prototyping.
218	</description>
219	<name>setDataSource</name>
220	<tag-class>org.apache.taglibs.standard.tag.rt.sql.SetDataSourceTag</tag-class>
221	<body-content>empty</body-content>
222	<attribute>
223	<description>	216	<description>
224	Name of the exported scoped variable	217	Creates a simple DataSource suitable only for prototyping.
225	for the data source specified. Type can
226	be String or DataSource.
227	</description>	218	</description>
228	<name>var</name>	219	<name>setDataSource</name>
229	<required>false</required>	220	<tag-class>org.apache.taglibs.standard.tag.rt.sql.SetDataSourceTag</tag-class>
230	<rtexprvalue>false</rtexprvalue>	221	<body-content>empty</body-content>
231	</attribute>	222	<attribute>
232	<attribute>	223	<description>
233	<description>	224	Name of the exported scoped variable
234	If var is specified, scope of the	225	for the data source specified. Type can
235	exported variable. Otherwise, scope of	226	be String or DataSource.
236	the data source configuration variable.	227	</description>
237	</description>	228	<name>var</name>
238	<name>scope</name>	229	<required>false</required>
239	<required>false</required>	230	<rtexprvalue>false</rtexprvalue>
240	<rtexprvalue>false</rtexprvalue>	231	</attribute>
241	</attribute>	232	<attribute>
242	<attribute>	233	<description>
243	<description>	234	If var is specified, scope of the
244	Data source. If specified as a string, it	235	exported variable. Otherwise, scope of
245	can either be a relative path to a JNDI	236	the data source configuration variable.
246	resource, or a JDBC parameters string	237	</description>
247	as defined in Section 10.1.1.	238	<name>scope</name>
248	</description>	239	<required>false</required>
249	<name>dataSource</name>	240	<rtexprvalue>false</rtexprvalue>
250	<required>false</required>	241	</attribute>
251	<rtexprvalue>true</rtexprvalue>	242	<attribute>
252	</attribute>	243	<description>
253	<attribute>	244	Data source. If specified as a string, it
254	<description>	245	can either be a relative path to a JNDI
255	JDBC parameter: driver class name.	246	resource, or a JDBC parameters string
256	</description>	247	as defined in Section 10.1.1.
257	<name>driver</name>	248	</description>
258	<required>false</required>	249	<name>dataSource</name>
259	<rtexprvalue>true</rtexprvalue>	250	<required>false</required>
260	</attribute>	251	<rtexprvalue>true</rtexprvalue>
261	<attribute>	252	</attribute>
262	<description>	253	<attribute>
263	JDBC parameter: URL associated with	254	<description>
264	the database.	255	JDBC parameter: driver class name.
265	</description>	256	</description>
266	<name>url</name>	257	<name>driver</name>
267	<required>false</required>	258	<required>false</required>
268	<rtexprvalue>true</rtexprvalue>	259	<rtexprvalue>true</rtexprvalue>
269	</attribute>	260	</attribute>
270	<attribute>	261	<attribute>
271	<description>	262	<description>
272	JDBC parameter: database user on	263	JDBC parameter: URL associated with
273	whose behalf the connection to the	264	the database.
274	database is being made.	265	</description>
275	</description>	266	<name>url</name>
276	<name>user</name>	267	<required>false</required>
277	<required>false</required>	268	<rtexprvalue>true</rtexprvalue>
278	<rtexprvalue>true</rtexprvalue>	269	</attribute>
279	</attribute>	270	<attribute>
280	<attribute>	271	<description>
281	<description>	272	JDBC parameter: database user on
282	JDBC parameter: user password	273	whose behalf the connection to the
283	</description>	274	database is being made.
284	<name>password</name>	275	</description>
285	<required>false</required>	276	<name>user</name>
286	<rtexprvalue>true</rtexprvalue>	277	<required>false</required>
287	</attribute>	278	<rtexprvalue>true</rtexprvalue>
288	</tag>	279	</attribute>
		280	<attribute>
		281	<description>
		282	JDBC parameter: user password
		283	</description>
		284	<name>password</name>
		285	<required>false</required>
		286	<rtexprvalue>true</rtexprvalue>
		287	</attribute>
		288	</tag>
289	</taglib>	289	</taglib>

Lines 1-393 Link Here

(-)src/main/resources/META-INF/c-1_0-rt.tld (-372 / +372 lines)
1	<?xml version="1.0" encoding="ISO-8859-1" ?>	1	<?xml version="1.0" encoding="ISO-8859-1" ?>
2	<!DOCTYPE taglib	2	<!DOCTYPE taglib
3	PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"	3	PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
4	"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">	4	"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
5	<taglib>	5	<taglib>
6	<tlib-version>1.0</tlib-version>	6	<tlib-version>1.0</tlib-version>
7	<jsp-version>1.2</jsp-version>	7	<jsp-version>1.2</jsp-version>
8	<short-name>c_rt</short-name>	8	<short-name>c_rt</short-name>
9	<uri>http://java.sun.com/jstl/core_rt</uri>	9	<uri>http://java.sun.com/jstl/core_rt</uri>
10	<display-name>JSTL core RT</display-name>	10	<display-name>JSTL core RT</display-name>
11	<description>JSTL 1.0 core library</description>	11	<description>JSTL 1.0 core library</description>
12		12
13	<validator>	13	<validator>
14	<validator-class>	14	<validator-class>
15	org.apache.taglibs.standard.tlv.JstlCoreTLV	15	org.apache.taglibs.standard.tlv.JstlCoreTLV
16	</validator-class>	16	</validator-class>
17	<description>	17	<description>
18	Provides core validation features for JSTL tags.	18	Provides core validation features for JSTL tags.
19	</description>	19	</description>
20	</validator>	20	</validator>
21		21
22	<tag>	22	<tag>
23	<name>catch</name>	23	<name>catch</name>
24	<tag-class>org.apache.taglibs.standard.tag.common.core.CatchTag</tag-class>	24	<tag-class>org.apache.taglibs.standard.tag.common.core.CatchTag</tag-class>
25	<body-content>JSP</body-content>	25	<body-content>JSP</body-content>
26	<description>	26	<description>
27	Catches any Throwable that occurs in its body and optionally	27	Catches any Throwable that occurs in its body and optionally
28	exposes it.	28	exposes it.
29	</description>	29	</description>
30	<attribute>	30	<attribute>
31	<name>var</name>	31	<name>var</name>
32	<required>false</required>	32	<required>false</required>
33	<rtexprvalue>false</rtexprvalue>	33	<rtexprvalue>false</rtexprvalue>
34	</attribute>	34	</attribute>
35	</tag>	35	</tag>
36		36
37	<tag>	37	<tag>
38	<name>choose</name>	38	<name>choose</name>
39	<tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>	39	<tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
40	<body-content>JSP</body-content>	40	<body-content>JSP</body-content>
41	<description>	41	<description>
42	Simple conditional tag that establishes a context for	42	Simple conditional tag that establishes a context for
43	mutually exclusive conditional operations, marked by	43	mutually exclusive conditional operations, marked by
44	<when> and <otherwise>	44	<when> and <otherwise>
45	</description>	45	</description>
46	</tag>	46	</tag>
47		47
48	<tag>	48	<tag>
49	<name>if</name>	49	<name>if</name>
50	<tag-class>org.apache.taglibs.standard.tag.rt.core.IfTag</tag-class>	50	<tag-class>org.apache.taglibs.standard.tag.rt.core.IfTag</tag-class>
51	<body-content>JSP</body-content>	51	<body-content>JSP</body-content>
52	<description>	52	<description>
53	Simple conditional tag, which evalutes its body if the	53	Simple conditional tag, which evalutes its body if the
54	supplied condition is true and optionally exposes a Boolean	54	supplied condition is true and optionally exposes a Boolean
55	scripting variable representing the evaluation of this condition	55	scripting variable representing the evaluation of this condition
56	</description>	56	</description>
57	<attribute>	57	<attribute>
58	<name>test</name>	58	<name>test</name>
59	<required>true</required>	59	<required>true</required>
60	<rtexprvalue>true</rtexprvalue>	60	<rtexprvalue>true</rtexprvalue>
61	<type>boolean</type>	61	<type>boolean</type>
62	</attribute>	62	</attribute>
63	<attribute>	63	<attribute>
64	<name>var</name>	64	<name>var</name>
65	<required>false</required>	65	<required>false</required>
66	<rtexprvalue>false</rtexprvalue>	66	<rtexprvalue>false</rtexprvalue>
67	</attribute>	67	</attribute>
68	<attribute>	68	<attribute>
69	<name>scope</name>	69	<name>scope</name>
70	<required>false</required>	70	<required>false</required>
71	<rtexprvalue>false</rtexprvalue>	71	<rtexprvalue>false</rtexprvalue>
72	</attribute>	72	</attribute>
73	</tag>	73	</tag>
74		74
75	<tag>	75	<tag>
76	<name>import</name>	76	<name>import</name>
77	<tag-class>org.apache.taglibs.standard.tag.rt.core.ImportTag</tag-class>	77	<tag-class>org.apache.taglibs.standard.tag.rt.core.ImportTag</tag-class>
78	<tei-class>org.apache.taglibs.standard.tei.ImportTEI</tei-class>	78	<tei-class>org.apache.taglibs.standard.tei.ImportTEI</tei-class>
79	<body-content>JSP</body-content>	79	<body-content>JSP</body-content>
80	<description>	80	<description>
81	Retrieves an absolute or relative URL and exposes its contents	81	Retrieves an absolute or relative URL and exposes its contents
82	to either the page, a String in 'var', or a Reader in 'varReader'.	82	to either the page, a String in 'var', or a Reader in 'varReader'.
83	</description>	83	</description>
84	<attribute>	84	<attribute>
85	<name>url</name>	85	<name>url</name>
86	<required>true</required>	86	<required>true</required>
87	<rtexprvalue>true</rtexprvalue>	87	<rtexprvalue>true</rtexprvalue>
88	</attribute>	88	</attribute>
89	<attribute>	89	<attribute>
90	<name>var</name>	90	<name>var</name>
91	<required>false</required>	91	<required>false</required>
92	<rtexprvalue>false</rtexprvalue>	92	<rtexprvalue>false</rtexprvalue>
93	</attribute>	93	</attribute>
94	<attribute>	94	<attribute>
95	<name>scope</name>	95	<name>scope</name>
96	<required>false</required>	96	<required>false</required>
97	<rtexprvalue>false</rtexprvalue>	97	<rtexprvalue>false</rtexprvalue>
98	</attribute>	98	</attribute>
99	<attribute>	99	<attribute>
100	<name>varReader</name>	100	<name>varReader</name>
101	<required>false</required>	101	<required>false</required>
102	<rtexprvalue>false</rtexprvalue>	102	<rtexprvalue>false</rtexprvalue>
103	</attribute>	103	</attribute>
104	<attribute>	104	<attribute>
105	<name>context</name>	105	<name>context</name>
106	<required>false</required>	106	<required>false</required>
107	<rtexprvalue>true</rtexprvalue>	107	<rtexprvalue>true</rtexprvalue>
108	</attribute>	108	</attribute>
109	<attribute>	109	<attribute>
110	<name>charEncoding</name>	110	<name>charEncoding</name>
111	<required>false</required>	111	<required>false</required>
112	<rtexprvalue>true</rtexprvalue>	112	<rtexprvalue>true</rtexprvalue>
113	</attribute>	113	</attribute>
114	</tag>	114	</tag>
115		115
116	<tag>	116	<tag>
117	<name>forEach</name>	117	<name>forEach</name>
118	<tag-class>org.apache.taglibs.standard.tag.rt.core.ForEachTag</tag-class>	118	<tag-class>org.apache.taglibs.standard.tag.rt.core.ForEachTag</tag-class>
119	<tei-class>org.apache.taglibs.standard.tei.ForEachTEI</tei-class>	119	<tei-class>org.apache.taglibs.standard.tei.ForEachTEI</tei-class>
120	<body-content>JSP</body-content>	120	<body-content>JSP</body-content>
121	<description>	121	<description>
122	The basic iteration tag, accepting many different	122	The basic iteration tag, accepting many different
123	collection types and supporting subsetting and other	123	collection types and supporting subsetting and other
124	functionality	124	functionality
125	</description>	125	</description>
126	<attribute>	126	<attribute>
127	<name>items</name>	127	<name>items</name>
128	<required>false</required>	128	<required>false</required>
129	<rtexprvalue>true</rtexprvalue>	129	<rtexprvalue>true</rtexprvalue>
130	<type>java.lang.Object</type>	130	<type>java.lang.Object</type>
131	</attribute>	131	</attribute>
132	<attribute>	132	<attribute>
133	<name>begin</name>	133	<name>begin</name>
134	<required>false</required>	134	<required>false</required>
135	<rtexprvalue>true</rtexprvalue>	135	<rtexprvalue>true</rtexprvalue>
136	<type>int</type>	136	<type>int</type>
137	</attribute>	137	</attribute>
138	<attribute>	138	<attribute>
139	<name>end</name>	139	<name>end</name>
140	<required>false</required>	140	<required>false</required>
141	<rtexprvalue>true</rtexprvalue>	141	<rtexprvalue>true</rtexprvalue>
142	<type>int</type>	142	<type>int</type>
143	</attribute>	143	</attribute>
144	<attribute>	144	<attribute>
145	<name>step</name>	145	<name>step</name>
146	<required>false</required>	146	<required>false</required>
147	<rtexprvalue>true</rtexprvalue>	147	<rtexprvalue>true</rtexprvalue>
148	<type>int</type>	148	<type>int</type>
149	</attribute>	149	</attribute>
150	<attribute>	150	<attribute>
151	<name>var</name>	151	<name>var</name>
152	<required>false</required>	152	<required>false</required>
153	<rtexprvalue>false</rtexprvalue>	153	<rtexprvalue>false</rtexprvalue>
154	</attribute>	154	</attribute>
155	<attribute>	155	<attribute>
156	<name>varStatus</name>	156	<name>varStatus</name>
157	<required>false</required>	157	<required>false</required>
158	<rtexprvalue>false</rtexprvalue>	158	<rtexprvalue>false</rtexprvalue>
159	</attribute>	159	</attribute>
160	</tag>	160	</tag>
161		161
162	<tag>	162	<tag>
163	<name>forTokens</name>	163	<name>forTokens</name>
164	<tag-class>org.apache.taglibs.standard.tag.rt.core.ForTokensTag</tag-class>	164	<tag-class>org.apache.taglibs.standard.tag.rt.core.ForTokensTag</tag-class>
165	<body-content>JSP</body-content>	165	<body-content>JSP</body-content>
166	<description>	166	<description>
167	Iterates over tokens, separated by the supplied delimeters	167	Iterates over tokens, separated by the supplied delimeters
168	</description>	168	</description>
169	<attribute>	169	<attribute>
170	<name>items</name>	170	<name>items</name>
171	<required>true</required>	171	<required>true</required>
172	<rtexprvalue>true</rtexprvalue>	172	<rtexprvalue>true</rtexprvalue>
173	<type>java.lang.String</type>	173	<type>java.lang.String</type>
174	</attribute>	174	</attribute>
175	<attribute>	175	<attribute>
176	<name>delims</name>	176	<name>delims</name>
177	<required>true</required>	177	<required>true</required>
178	<rtexprvalue>true</rtexprvalue>	178	<rtexprvalue>true</rtexprvalue>
179	<type>java.lang.String</type>	179	<type>java.lang.String</type>
180	</attribute>	180	</attribute>
181	<attribute>	181	<attribute>
182	<name>begin</name>	182	<name>begin</name>
183	<required>false</required>	183	<required>false</required>
184	<rtexprvalue>true</rtexprvalue>	184	<rtexprvalue>true</rtexprvalue>
185	<type>int</type>	185	<type>int</type>
186	</attribute>	186	</attribute>
187	<attribute>	187	<attribute>
188	<name>end</name>	188	<name>end</name>
189	<required>false</required>	189	<required>false</required>
190	<rtexprvalue>true</rtexprvalue>	190	<rtexprvalue>true</rtexprvalue>
191	<type>int</type>	191	<type>int</type>
192	</attribute>	192	</attribute>
193	<attribute>	193	<attribute>
194	<name>step</name>	194	<name>step</name>
195	<required>false</required>	195	<required>false</required>
196	<rtexprvalue>true</rtexprvalue>	196	<rtexprvalue>true</rtexprvalue>
197	<type>int</type>	197	<type>int</type>
198	</attribute>	198	</attribute>
199	<attribute>	199	<attribute>
200	<name>var</name>	200	<name>var</name>
201	<required>false</required>	201	<required>false</required>
202	<rtexprvalue>false</rtexprvalue>	202	<rtexprvalue>false</rtexprvalue>
203	</attribute>	203	</attribute>
204	<attribute>	204	<attribute>
205	<name>varStatus</name>	205	<name>varStatus</name>
206	<required>false</required>	206	<required>false</required>
207	<rtexprvalue>false</rtexprvalue>	207	<rtexprvalue>false</rtexprvalue>
208	</attribute>	208	</attribute>
209	</tag>	209	</tag>
210		210
211	<tag>	211	<tag>
212	<name>out</name>	212	<name>out</name>
213	<tag-class>org.apache.taglibs.standard.tag.rt.core.OutTag</tag-class>	213	<tag-class>org.apache.taglibs.standard.tag.rt.core.OutTag</tag-class>
214	<body-content>JSP</body-content>	214	<body-content>JSP</body-content>
215	<description>	215	<description>
216	Like <%= ... >, but for expressions.	216	Like <%= ... >, but for expressions.
217	</description>	217	</description>
218	<attribute>	218	<attribute>
219	<name>value</name>	219	<name>value</name>
220	<required>true</required>	220	<required>true</required>
221	<rtexprvalue>true</rtexprvalue>	221	<rtexprvalue>true</rtexprvalue>
222	</attribute>	222	</attribute>
223	<attribute>	223	<attribute>
224	<name>default</name>	224	<name>default</name>
225	<required>false</required>	225	<required>false</required>
226	<rtexprvalue>true</rtexprvalue>	226	<rtexprvalue>true</rtexprvalue>
227	</attribute>	227	</attribute>
228	<attribute>	228	<attribute>
229	<name>escapeXml</name>	229	<name>escapeXml</name>
230	<required>false</required>	230	<required>false</required>
231	<rtexprvalue>true</rtexprvalue>	231	<rtexprvalue>true</rtexprvalue>
232	</attribute>	232	</attribute>
233	</tag>	233	</tag>
234		234
235		235
236	<tag>	236	<tag>
237	<name>otherwise</name>	237	<name>otherwise</name>
238	<tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>	238	<tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
239	<body-content>JSP</body-content>	239	<body-content>JSP</body-content>
240	<description>	240	<description>
241	Subtag of <choose> that follows <when> tags	241	Subtag of <choose> that follows <when> tags
242	and runs only if all of the prior conditions evaluated to	242	and runs only if all of the prior conditions evaluated to
243	'false'	243	'false'
244	</description>	244	</description>
245	</tag>	245	</tag>
246		246
247	<tag>	247	<tag>
248	<name>param</name>	248	<name>param</name>
249	<tag-class>org.apache.taglibs.standard.tag.rt.core.ParamTag</tag-class>	249	<tag-class>org.apache.taglibs.standard.tag.rt.core.ParamTag</tag-class>
250	<body-content>JSP</body-content>	250	<body-content>JSP</body-content>
251	<description>	251	<description>
252	Adds a parameter to a containing 'import' tag's URL.	252	Adds a parameter to a containing 'import' tag's URL.
253	</description>	253	</description>
254	<attribute>	254	<attribute>
255	<name>name</name>	255	<name>name</name>
256	<required>true</required>	256	<required>true</required>
257	<rtexprvalue>true</rtexprvalue>	257	<rtexprvalue>true</rtexprvalue>
258	</attribute>	258	</attribute>
259	<attribute>	259	<attribute>
260	<name>value</name>	260	<name>value</name>
261	<required>false</required>	261	<required>false</required>
262	<rtexprvalue>true</rtexprvalue>	262	<rtexprvalue>true</rtexprvalue>
263	</attribute>	263	</attribute>
264	</tag>	264	</tag>
265		265
266	<tag>	266	<tag>
267	<name>redirect</name>	267	<name>redirect</name>
268	<tag-class>org.apache.taglibs.standard.tag.rt.core.RedirectTag</tag-class>	268	<tag-class>org.apache.taglibs.standard.tag.rt.core.RedirectTag</tag-class>
269	<body-content>JSP</body-content>	269	<body-content>JSP</body-content>
270	<description>	270	<description>
271	Redirects to a new URL.	271	Redirects to a new URL.
272	</description>	272	</description>
273	<attribute>	273	<attribute>
274	<name>var</name>	274	<name>var</name>
275	<required>false</required>	275	<required>false</required>
276	<rtexprvalue>false</rtexprvalue>	276	<rtexprvalue>false</rtexprvalue>
277	</attribute>	277	</attribute>
278	<attribute>	278	<attribute>
279	<name>scope</name>	279	<name>scope</name>
280	<required>false</required>	280	<required>false</required>
281	<rtexprvalue>false</rtexprvalue>	281	<rtexprvalue>false</rtexprvalue>
282	</attribute>	282	</attribute>
283	<attribute>	283	<attribute>
284	<name>url</name>	284	<name>url</name>
285	<required>false</required>	285	<required>false</required>
286	<rtexprvalue>true</rtexprvalue>	286	<rtexprvalue>true</rtexprvalue>
287	</attribute>	287	</attribute>
288	<attribute>	288	<attribute>
289	<name>context</name>	289	<name>context</name>
290	<required>false</required>	290	<required>false</required>
291	<rtexprvalue>true</rtexprvalue>	291	<rtexprvalue>true</rtexprvalue>
292	</attribute>	292	</attribute>
293	</tag>	293	</tag>
294		294
295	<tag>	295	<tag>
296	<name>remove</name>	296	<name>remove</name>
297	<tag-class>org.apache.taglibs.standard.tag.common.core.RemoveTag</tag-class>	297	<tag-class>org.apache.taglibs.standard.tag.common.core.RemoveTag</tag-class>
298	<body-content>empty</body-content>	298	<body-content>empty</body-content>
299	<description>	299	<description>
300	Removes a scoped variable (from a particular scope, if specified).	300	Removes a scoped variable (from a particular scope, if specified).
301	</description>	301	</description>
302	<attribute>	302	<attribute>
303	<name>var</name>	303	<name>var</name>
304	<required>true</required>	304	<required>true</required>
305	<rtexprvalue>false</rtexprvalue>	305	<rtexprvalue>false</rtexprvalue>
306	</attribute>	306	</attribute>
307	<attribute>	307	<attribute>
308	<name>scope</name>	308	<name>scope</name>
309	<required>false</required>	309	<required>false</required>
310	<rtexprvalue>false</rtexprvalue>	310	<rtexprvalue>false</rtexprvalue>
311	</attribute>	311	</attribute>
312	</tag>	312	</tag>
313		313
314	<tag>	314	<tag>
315	<name>set</name>	315	<name>set</name>
316	<tag-class>org.apache.taglibs.standard.tag.rt.core.SetTag</tag-class>	316	<tag-class>org.apache.taglibs.standard.tag.rt.core.SetTag</tag-class>
317	<body-content>JSP</body-content>	317	<body-content>JSP</body-content>
318	<description>	318	<description>
319	Sets the result of an expression evaluation in a 'scope'	319	Sets the result of an expression evaluation in a 'scope'
320	</description>	320	</description>
321	<attribute>	321	<attribute>
322	<name>var</name>	322	<name>var</name>
323	<required>false</required>	323	<required>false</required>
324	<rtexprvalue>false</rtexprvalue>	324	<rtexprvalue>false</rtexprvalue>
325	</attribute>	325	</attribute>
326	<attribute>	326	<attribute>
327	<name>value</name>	327	<name>value</name>
328	<required>false</required>	328	<required>false</required>
329	<rtexprvalue>true</rtexprvalue>	329	<rtexprvalue>true</rtexprvalue>
330	</attribute>	330	</attribute>
331	<attribute>	331	<attribute>
332	<name>target</name>	332	<name>target</name>
333	<required>false</required>	333	<required>false</required>
334	<rtexprvalue>true</rtexprvalue>	334	<rtexprvalue>true</rtexprvalue>
335	</attribute>	335	</attribute>
336	<attribute>	336	<attribute>
337	<name>property</name>	337	<name>property</name>
338	<required>false</required>	338	<required>false</required>
339	<rtexprvalue>true</rtexprvalue>	339	<rtexprvalue>true</rtexprvalue>
340	</attribute>	340	</attribute>
341	<attribute>	341	<attribute>
342	<name>scope</name>	342	<name>scope</name>
343	<required>false</required>	343	<required>false</required>
344	<rtexprvalue>false</rtexprvalue>	344	<rtexprvalue>false</rtexprvalue>
345	</attribute>	345	</attribute>
346	</tag>	346	</tag>
347		347
348	<tag>	348	<tag>
349	<name>url</name>	349	<name>url</name>
350	<tag-class>org.apache.taglibs.standard.tag.rt.core.UrlTag</tag-class>	350	<tag-class>org.apache.taglibs.standard.tag.rt.core.UrlTag</tag-class>
351	<body-content>JSP</body-content>	351	<body-content>JSP</body-content>
352	<description>	352	<description>
353	Creates a URL with optional query parameters.	353	Creates a URL with optional query parameters.
354	</description>	354	</description>
355	<attribute>	355	<attribute>
356	<name>var</name>	356	<name>var</name>
357	<required>false</required>	357	<required>false</required>
358	<rtexprvalue>false</rtexprvalue>	358	<rtexprvalue>false</rtexprvalue>
359	</attribute>	359	</attribute>
360	<attribute>	360	<attribute>
361	<name>scope</name>	361	<name>scope</name>
362	<required>false</required>	362	<required>false</required>
363	<rtexprvalue>false</rtexprvalue>	363	<rtexprvalue>false</rtexprvalue>
364	</attribute>	364	</attribute>
365	<attribute>	365	<attribute>
366	<name>value</name>	366	<name>value</name>
367	<required>false</required>	367	<required>false</required>
368	<rtexprvalue>true</rtexprvalue>	368	<rtexprvalue>true</rtexprvalue>
369	</attribute>	369	</attribute>
370	<attribute>	370	<attribute>
371	<name>context</name>	371	<name>context</name>
372	<required>false</required>	372	<required>false</required>
373	<rtexprvalue>true</rtexprvalue>	373	<rtexprvalue>true</rtexprvalue>
374	</attribute>	374	</attribute>
375	</tag>	375	</tag>
376		376
377	<tag>	377	<tag>
378	<name>when</name>	378	<name>when</name>
379	<tag-class>org.apache.taglibs.standard.tag.rt.core.WhenTag</tag-class>	379	<tag-class>org.apache.taglibs.standard.tag.rt.core.WhenTag</tag-class>
380	<body-content>JSP</body-content>	380	<body-content>JSP</body-content>
381	<description>	381	<description>
382	Subtag of <choose> that includes its body if its	382	Subtag of <choose> that includes its body if its
383	condition evalutes to 'true'	383	condition evalutes to 'true'
384	</description>	384	</description>
385	<attribute>	385	<attribute>
386	<name>test</name>	386	<name>test</name>
387	<required>true</required>	387	<required>true</required>
388	<rtexprvalue>true</rtexprvalue>	388	<rtexprvalue>true</rtexprvalue>
389	<type>boolean</type>	389	<type>boolean</type>
390	</attribute>	390	</attribute>
391	</tag>	391	</tag>
392		392
393	</taglib>	393	</taglib>

Lines 1-207 Link Here

(-)src/main/resources/META-INF/fn.tld (-186 / +187 lines)
1	<?xml version="1.0" encoding="UTF-8" ?>	1	<?xml version="1.0" encoding="UTF-8" ?>
2		2
3	<taglib xmlns="http://java.sun.com/xml/ns/j2ee"	3	<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
4	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"	4	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"	5	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
6	version="2.0">	6	version="2.0">
7
8	<description>JSTL 1.1 functions library</description>
9	<display-name>JSTL functions</display-name>
10	<tlib-version>1.1</tlib-version>
11	<short-name>fn</short-name>
12	<uri>http://java.sun.com/jsp/jstl/functions</uri>
13		7
14	<function>	8	<description>JSTL 1.1 functions library</description>
15	<description>	9	<display-name>JSTL functions</display-name>
16	Tests if an input string contains the specified substring.	10	<tlib-version>1.1</tlib-version>
17	</description>	11	<short-name>fn</short-name>
18	<name>contains</name>	12	<uri>http://java.sun.com/jsp/jstl/functions</uri>
19	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
20	<function-signature>boolean contains(java.lang.String, java.lang.String)</function-signature>
21	<example>
22	<c:if test="${fn:contains(name, searchString)}">
23	</example>
24	</function>
25		13
26	<function>	14	<function>
27	<description>	15	<description>
28	Tests if an input string contains the specified substring in a case insensitive way.	16	Tests if an input string contains the specified substring.
29	</description>	17	</description>
30	<name>containsIgnoreCase</name>	18	<name>contains</name>
31	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	19	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
32	<function-signature>boolean containsIgnoreCase(java.lang.String, java.lang.String)</function-signature>	20	<function-signature>boolean contains(java.lang.String, java.lang.String)</function-signature>
33	<example>	21	<example>
34	<c:if test="${fn:containsIgnoreCase(name, searchString)}">	22	<c:if test="${fn:contains(name, searchString)}">
35	</example>	23	</example>
36	</function>	24	</function>
37		25
38	<function>	26	<function>
39	<description>	27	<description>
40	Tests if an input string ends with the specified suffix.	28	Tests if an input string contains the specified substring in a case insensitive way.
41	</description>	29	</description>
42	<name>endsWith</name>	30	<name>containsIgnoreCase</name>
43	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	31	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
44	<function-signature>boolean endsWith(java.lang.String, java.lang.String)</function-signature>	32	<function-signature>boolean containsIgnoreCase(java.lang.String, java.lang.String)</function-signature>
45	<example>	33	<example>
46	<c:if test="${fn:endsWith(filename, ".txt")}">	34	<c:if test="${fn:containsIgnoreCase(name, searchString)}">
47	</example>	35	</example>
48	</function>	36	</function>
49		37
50	<function>	38	<function>
51	<description>	39	<description>
52	Escapes characters that could be interpreted as XML markup.	40	Tests if an input string ends with the specified suffix.
53	</description>	41	</description>
54	<name>escapeXml</name>	42	<name>endsWith</name>
55	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	43	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
56	<function-signature>java.lang.String escapeXml(java.lang.String)</function-signature>	44	<function-signature>boolean endsWith(java.lang.String, java.lang.String)</function-signature>
57	<example>	45	<example>
58	${fn:escapeXml(param:info)}	46	<c:if test="${fn:endsWith(filename, ".txt")}">
59	</example>	47	</example>
60	</function>	48	</function>
61		49
62	<function>	50	<function>
63	<description>	51	<description>
64	Returns the index withing a string of the first occurrence of a specified substring.	52	Escapes characters that could be interpreted as XML markup.
65	</description>	53	</description>
66	<name>indexOf</name>	54	<name>escapeXml</name>
67	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	55	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
68	<function-signature>int indexOf(java.lang.String, java.lang.String)</function-signature>	56	<function-signature>java.lang.String escapeXml(java.lang.String)</function-signature>
69	<example>	57	<example>
70	${fn:indexOf(name, "-")}	58	${fn:escapeXml(param:info)}
71	</example>	59	</example>
72	</function>	60	</function>
73		61
74	<function>	62	<function>
75	<description>	63	<description>
76	Joins all elements of an array into a string.	64	Returns the index withing a string of the first occurrence of a specified substring.
77	</description>	65	</description>
78	<name>join</name>	66	<name>indexOf</name>
79	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	67	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
80	<function-signature>java.lang.String join(java.lang.String[], java.lang.String)</function-signature>	68	<function-signature>int indexOf(java.lang.String, java.lang.String)</function-signature>
81	<example>	69	<example>
82	${fn:join(array, ";")}	70	${fn:indexOf(name, "-")}
83	</example>	71	</example>
84	</function>	72	</function>
85		73
86	<function>	74	<function>
87	<description>	75	<description>
88	Returns the number of items in a collection, or the number of characters in a string.	76	Joins all elements of an array into a string.
89	</description>	77	</description>
90	<name>length</name>	78	<name>join</name>
91	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	79	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
92	<function-signature>int length(java.lang.Object)</function-signature>	80	<function-signature>java.lang.String join(java.lang.String[], java.lang.String)</function-signature>
93	<example>	81	<example>
94	You have ${fn:length(shoppingCart.products)} in your shopping cart.	82	${fn:join(array, ";")}
95	</example>	83	</example>
96	</function>	84	</function>
97		85
98	<function>	86	<function>
99	<description>	87	<description>
100	Returns a string resulting from replacing in an input string all occurrences	88	Returns the number of items in a collection, or the number of characters in a string.
101	of a "before" string into an "after" substring.	89	</description>
102	</description>	90	<name>length</name>
103	<name>replace</name>	91	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
104	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	92	<function-signature>int length(java.lang.Object)</function-signature>
105	<function-signature>java.lang.String replace(java.lang.String, java.lang.String, java.lang.String)</function-signature>	93	<example>
106	<example>	94	You have ${fn:length(shoppingCart.products)} in your shopping cart.
107	${fn:replace(text, "-", "")}	95	</example>
108	</example>	96	</function>
109	</function>
110		97
111	<function>	98	<function>
112	<description>	99	<description>
113	Splits a string into an array of substrings.	100	Returns a string resulting from replacing in an input string all occurrences
114	</description>	101	of a "before" string into an "after" substring.
115	<name>split</name>	102	</description>
116	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	103	<name>replace</name>
117	<function-signature>java.lang.String[] split(java.lang.String, java.lang.String)</function-signature>	104	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
118	<example>	105	<function-signature>java.lang.String replace(java.lang.String, java.lang.String, java.lang.String)
119	${fn:split(customerNames, ";")}	106	</function-signature>
120	</example>	107	<example>
121	</function>	108	${fn:replace(text, "-", "")}
		109	</example>
		110	</function>
122		111
123	<function>	112	<function>
124	<description>	113	<description>
125	Tests if an input string starts with the specified prefix.	114	Splits a string into an array of substrings.
126	</description>	115	</description>
127	<name>startsWith</name>	116	<name>split</name>
128	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	117	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
129	<function-signature>boolean startsWith(java.lang.String, java.lang.String)</function-signature>	118	<function-signature>java.lang.String[] split(java.lang.String, java.lang.String)</function-signature>
130	<example>	119	<example>
131	<c:if test="${fn:startsWith(product.id, "100-")}">	120	${fn:split(customerNames, ";")}
132	</example>	121	</example>
133	</function>	122	</function>
134		123
135	<function>	124	<function>
136	<description>	125	<description>
137	Returns a subset of a string.	126	Tests if an input string starts with the specified prefix.
138	</description>	127	</description>
139	<name>substring</name>	128	<name>startsWith</name>
140	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	129	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
141	<function-signature>java.lang.String substring(java.lang.String, int, int)</function-signature>	130	<function-signature>boolean startsWith(java.lang.String, java.lang.String)</function-signature>
142	<example>	131	<example>
143	P.O. Box: ${fn:substring(zip, 6, -1)}	132	<c:if test="${fn:startsWith(product.id, "100-")}">
144	</example>	133	</example>
145	</function>	134	</function>
146		135
147	<function>	136	<function>
148	<description>	137	<description>
149	Returns a subset of a string following a specific substring.	138	Returns a subset of a string.
150	</description>	139	</description>
151	<name>substringAfter</name>	140	<name>substring</name>
152	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	141	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
153	<function-signature>java.lang.String substringAfter(java.lang.String, java.lang.String)</function-signature>	142	<function-signature>java.lang.String substring(java.lang.String, int, int)</function-signature>
154	<example>	143	<example>
155	P.O. Box: ${fn:substringAfter(zip, "-")}	144	P.O. Box: ${fn:substring(zip, 6, -1)}
156	</example>	145	</example>
157	</function>	146	</function>
158		147
159	<function>	148	<function>
160	<description>	149	<description>
161	Returns a subset of a string before a specific substring.	150	Returns a subset of a string following a specific substring.
162	</description>	151	</description>
163	<name>substringBefore</name>	152	<name>substringAfter</name>
164	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	153	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
165	<function-signature>java.lang.String substringBefore(java.lang.String, java.lang.String)</function-signature>	154	<function-signature>java.lang.String substringAfter(java.lang.String, java.lang.String)</function-signature>
166	<example>	155	<example>
167	Zip (without P.O. Box): ${fn:substringBefore(zip, "-")}	156	P.O. Box: ${fn:substringAfter(zip, "-")}
168	</example>	157	</example>
169	</function>	158	</function>
170		159
171	<function>	160	<function>
172	<description>	161	<description>
173	Converts all of the characters of a string to lower case.	162	Returns a subset of a string before a specific substring.
174	</description>	163	</description>
175	<name>toLowerCase</name>	164	<name>substringBefore</name>
176	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	165	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
177	<function-signature>java.lang.String toLowerCase(java.lang.String)</function-signature>	166	<function-signature>java.lang.String substringBefore(java.lang.String, java.lang.String)</function-signature>
178	<example>	167	<example>
179	Product name: ${fn.toLowerCase(product.name)}	168	Zip (without P.O. Box): ${fn:substringBefore(zip, "-")}
180	</example>	169	</example>
181	</function>	170	</function>
182		171
183	<function>	172	<function>
184	<description>	173	<description>
185	Converts all of the characters of a string to upper case.	174	Converts all of the characters of a string to lower case.
186	</description>	175	</description>
187	<name>toUpperCase</name>	176	<name>toLowerCase</name>
188	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	177	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
189	<function-signature>java.lang.String toUpperCase(java.lang.String)</function-signature>	178	<function-signature>java.lang.String toLowerCase(java.lang.String)</function-signature>
190	<example>	179	<example>
191	Product name: ${fn.UpperCase(product.name)}	180	Product name: ${fn.toLowerCase(product.name)}
192	</example>	181	</example>
193	</function>	182	</function>
194		183
195	<function>	184	<function>
196	<description>	185	<description>
197	Removes white spaces from both ends of a string.	186	Converts all of the characters of a string to upper case.
198	</description>	187	</description>
199	<name>trim</name>	188	<name>toUpperCase</name>
200	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>	189	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
201	<function-signature>java.lang.String trim(java.lang.String)</function-signature>	190	<function-signature>java.lang.String toUpperCase(java.lang.String)</function-signature>
202	<example>	191	<example>
203	Name: ${fn.trim(name)}	192	Product name: ${fn.UpperCase(product.name)}
204	</example>	193	</example>
205	</function>	194	</function>
206		195
		196	<function>
		197	<description>
		198	Removes white spaces from both ends of a string.
		199	</description>
		200	<name>trim</name>
		201	<function-class>org.apache.taglibs.standard.functions.Functions</function-class>
		202	<function-signature>java.lang.String trim(java.lang.String)</function-signature>
		203	<example>
		204	Name: ${fn.trim(name)}
		205	</example>
		206	</function>
		207
207	</taglib>	208	</taglib>

Lines 1-34 Link Here

(-)src/main/resources/META-INF/permittedTaglibs.tld (-29 / +29 lines)
1	<?xml version="1.0" encoding="UTF-8" ?>	1	<?xml version="1.0" encoding="UTF-8" ?>
2		2
3	<taglib xmlns="http://java.sun.com/xml/ns/j2ee"	3	<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
4	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"	4	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"	5	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
6	version="2.0">	6	version="2.0">
7	<description>	7	<description>
8	Restricts JSP pages to the JSTL tag libraries	8	Restricts JSP pages to the JSTL tag libraries
9	</description>	9	</description>
10	<display-name>permittedTaglibs</display-name>	10	<display-name>permittedTaglibs</display-name>
11	<tlib-version>1.1</tlib-version>	11	<tlib-version>1.1</tlib-version>
12	<short-name>permittedTaglibs</short-name>	12	<short-name>permittedTaglibs</short-name>
13	<uri>http://jakarta.apache.org/taglibs/standard/permittedTaglibs</uri>	13	<uri>http://jakarta.apache.org/taglibs/standard/permittedTaglibs</uri>
14		14
15	<validator>	15	<validator>
16	<validator-class>	16	<validator-class>
17	javax.servlet.jsp.jstl.tlv.PermittedTaglibsTLV	17	javax.servlet.jsp.jstl.tlv.PermittedTaglibsTLV
18	</validator-class>	18	</validator-class>
19	<init-param>	19	<init-param>
20	<description>	20	<description>
21	Whitespace-separated list of taglib URIs to permit. This example	21	Whitespace-separated list of taglib URIs to permit. This example
22	TLD for the Standard Taglib allows only JSTL 'el' taglibs to be	22	TLD for the Standard Taglib allows only JSTL 'el' taglibs to be
23	imported.	23	imported.
24	</description>	24	</description>
25	<param-name>permittedTaglibs</param-name>	25	<param-name>permittedTaglibs</param-name>
26	<param-value>	26	<param-value>
27	http://java.sun.com/jsp/jstl/core	27	http://java.sun.com/jsp/jstl/core
28	http://java.sun.com/jsp/jstl/fmt	28	http://java.sun.com/jsp/jstl/fmt
29	http://java.sun.com/jsp/jstl/sql	29	http://java.sun.com/jsp/jstl/sql
30	http://java.sun.com/jsp/jstl/xml	30	http://java.sun.com/jsp/jstl/xml
31	</param-value>	31	</param-value>
32	</init-param>	32	</init-param>
33	</validator>	33	</validator>
34	</taglib>	34	</taglib>

Lines 1-51 Link Here

(-)src/main/resources/META-INF/scriptfree.tld (-45 / +45 lines)
1	<?xml version="1.0" encoding="UTF-8" ?>	1	<?xml version="1.0" encoding="UTF-8" ?>
2		2
3	<taglib xmlns="http://java.sun.com/xml/ns/j2ee"	3	<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
4	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"	4	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"	5	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
6	version="2.0">	6	version="2.0">
7	<description>
8	Validates JSP pages to prohibit use of scripting elements.
9	</description>
10	<tlib-version>1.1</tlib-version>
11	<short-name>scriptfree</short-name>
12	<uri>http://jakarta.apache.org/taglibs/standard/scriptfree</uri>
13
14	<validator>
15	<description>	7	<description>
16	Validates prohibitions against scripting elements.	8	Validates JSP pages to prohibit use of scripting elements.
17	</description>	9	</description>
18	<validator-class>	10	<tlib-version>1.1</tlib-version>
19	javax.servlet.jsp.jstl.tlv.ScriptFreeTLV	11	<short-name>scriptfree</short-name>
20	</validator-class>	12	<uri>http://jakarta.apache.org/taglibs/standard/scriptfree</uri>
21	<init-param>	13
22	<description>	14	<validator>
23	Controls whether or not declarations are considered valid.	15	<description>
24	</description>	16	Validates prohibitions against scripting elements.
25	<param-name>allowDeclarations</param-name>	17	</description>
26	<param-value>false</param-value>	18	<validator-class>
27	</init-param>	19	javax.servlet.jsp.jstl.tlv.ScriptFreeTLV
28	<init-param>	20	</validator-class>
29	<description>	21	<init-param>
30	Controls whether or not scriptlets are considered valid.	22	<description>
31	</description>	23	Controls whether or not declarations are considered valid.
32	<param-name>allowScriptlets</param-name>	24	</description>
33	<param-value>false</param-value>	25	<param-name>allowDeclarations</param-name>
34	</init-param>	26	<param-value>false</param-value>
35	<init-param>	27	</init-param>
36	<description>	28	<init-param>
37	Controls whether or not top-level expressions are considered valid.	29	<description>
38	</description>	30	Controls whether or not scriptlets are considered valid.
39	<param-name>allowExpressions</param-name>	31	</description>
40	<param-value>false</param-value>	32	<param-name>allowScriptlets</param-name>
41	</init-param>	33	<param-value>false</param-value>
42	<init-param>	34	</init-param>
43	<description>	35	<init-param>
44	Controls whether or not expressions used to supply request-time	36	<description>
45	attribute values are considered valid.	37	Controls whether or not top-level expressions are considered valid.
46	</description>	38	</description>
47	<param-name>allowRTExpressions</param-name>	39	<param-name>allowExpressions</param-name>
48	<param-value>false</param-value>	40	<param-value>false</param-value>
49	</init-param>	41	</init-param>
50	</validator>	42	<init-param>
		43	<description>
		44	Controls whether or not expressions used to supply request-time
		45	attribute values are considered valid.
		46	</description>
		47	<param-name>allowRTExpressions</param-name>
		48	<param-value>false</param-value>
		49	</init-param>
		50	</validator>
51	</taglib>	51	</taglib>

Lines 1-403 Link Here

(-)src/main/resources/META-INF/fmt-1_0-rt.tld (-385 / +385 lines)
1	<?xml version="1.0" encoding="ISO-8859-1" ?>	1	<?xml version="1.0" encoding="ISO-8859-1" ?>
2	<!DOCTYPE taglib	2	<!DOCTYPE taglib
3	PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"	3	PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
4	"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">	4	"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
5	<taglib>	5	<taglib>
6	<tlib-version>1.0</tlib-version>	6	<tlib-version>1.0</tlib-version>
7	<jsp-version>1.2</jsp-version>	7	<jsp-version>1.2</jsp-version>
8	<short-name>fmt_rt</short-name>	8	<short-name>fmt_rt</short-name>
9	<uri>http://java.sun.com/jstl/fmt_rt</uri>	9	<uri>http://java.sun.com/jstl/fmt_rt</uri>
10	<display-name>JSTL fmt RT</display-name>	10	<display-name>JSTL fmt RT</display-name>
11	<description>JSTL 1.0 i18n-capable formatting library</description>	11	<description>JSTL 1.0 i18n-capable formatting library</description>
12		12
13	<validator>	13	<validator>
14	<validator-class>	14	<validator-class>
15	org.apache.taglibs.standard.tlv.JstlFmtTLV	15	org.apache.taglibs.standard.tlv.JstlFmtTLV
16	</validator-class>	16	</validator-class>
17	<description>	17	<description>
18	Provides core validation features for JSTL tags.	18	Provides core validation features for JSTL tags.
19	</description>	19	</description>
20	</validator>	20	</validator>
21		21
22	<tag>	22	<tag>
23	<name>requestEncoding</name>	23	<name>requestEncoding</name>
24	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.RequestEncodingTag</tag-class>	24	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.RequestEncodingTag</tag-class>
25	<body-content>empty</body-content>	25	<body-content>empty</body-content>
26	<description>	26	<description>
27	Sets the request character encoding	27	Sets the request character encoding
28	</description>	28	</description>
29	<attribute>	29	<attribute>
30	<name>value</name>	30	<name>value</name>
31	<required>false</required>	31	<required>false</required>
32	<rtexprvalue>true</rtexprvalue>	32	<rtexprvalue>true</rtexprvalue>
33	</attribute>	33	</attribute>
34	</tag>	34	</tag>
35		35
36	<tag>	36	<tag>
37	<name>setLocale</name>	37	<name>setLocale</name>
38	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetLocaleTag</tag-class>	38	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetLocaleTag</tag-class>
39	<body-content>empty</body-content>	39	<body-content>empty</body-content>
40	<description>	40	<description>
41	Stores the given locale in the locale configuration variable	41	Stores the given locale in the locale configuration variable
42	</description>	42	</description>
43	<attribute>	43	<attribute>
44	<name>value</name>	44	<name>value</name>
45	<required>true</required>	45	<required>true</required>
46	<rtexprvalue>true</rtexprvalue>	46	<rtexprvalue>true</rtexprvalue>
47	</attribute>	47	</attribute>
48	<attribute>	48	<attribute>
49	<name>variant</name>	49	<name>variant</name>
50	<required>false</required>	50	<required>false</required>
51	<rtexprvalue>true</rtexprvalue>	51	<rtexprvalue>true</rtexprvalue>
52	</attribute>	52	</attribute>
53	<attribute>	53	<attribute>
54	<name>scope</name>	54	<name>scope</name>
55	<required>false</required>	55	<required>false</required>
56	<rtexprvalue>false</rtexprvalue>	56	<rtexprvalue>false</rtexprvalue>
57	</attribute>	57	</attribute>
58	</tag>	58	</tag>
59		59
60	<tag>	60	<tag>
61	<name>timeZone</name>	61	<name>timeZone</name>
62	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.TimeZoneTag</tag-class>	62	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.TimeZoneTag</tag-class>
63	<body-content>JSP</body-content>	63	<body-content>JSP</body-content>
64	<description>	64	<description>
65	Specifies the time zone for any time formatting or parsing actions	65	Specifies the time zone for any time formatting or parsing actions
66	nested in its body	66	nested in its body
67	</description>	67	</description>
68	<attribute>	68	<attribute>
69	<name>value</name>	69	<name>value</name>
70	<required>true</required>	70	<required>true</required>
71	<rtexprvalue>true</rtexprvalue>	71	<rtexprvalue>true</rtexprvalue>
72	</attribute>	72	</attribute>
73	</tag>	73	</tag>
74		74
75	<tag>	75	<tag>
76	<name>setTimeZone</name>	76	<name>setTimeZone</name>
77	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetTimeZoneTag</tag-class>	77	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetTimeZoneTag</tag-class>
78	<body-content>empty</body-content>	78	<body-content>empty</body-content>
79	<description>	79	<description>
80	Stores the given time zone in the time zone configuration variable	80	Stores the given time zone in the time zone configuration variable
81	</description>	81	</description>
82	<attribute>	82	<attribute>
83	<name>value</name>	83	<name>value</name>
84	<required>true</required>	84	<required>true</required>
85	<rtexprvalue>true</rtexprvalue>	85	<rtexprvalue>true</rtexprvalue>
86	</attribute>	86	</attribute>
87	<attribute>	87	<attribute>
88	<name>var</name>	88	<name>var</name>
89	<required>false</required>	89	<required>false</required>
90	<rtexprvalue>false</rtexprvalue>	90	<rtexprvalue>false</rtexprvalue>
91	</attribute>	91	</attribute>
92	<attribute>	92	<attribute>
93	<name>scope</name>	93	<name>scope</name>
94	<required>false</required>	94	<required>false</required>
95	<rtexprvalue>false</rtexprvalue>	95	<rtexprvalue>false</rtexprvalue>
96	</attribute>	96	</attribute>
97	</tag>	97	</tag>
98		98
99	<tag>	99	<tag>
100	<name>bundle</name>	100	<name>bundle</name>
101	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.BundleTag</tag-class>	101	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.BundleTag</tag-class>
102	<body-content>JSP</body-content>	102	<body-content>JSP</body-content>
103	<description>	103	<description>
104	Loads a resource bundle to be used by its tag body	104	Loads a resource bundle to be used by its tag body
105	</description>	105	</description>
106	<attribute>	106	<attribute>
107	<name>basename</name>	107	<name>basename</name>
108	<required>true</required>	108	<required>true</required>
109	<rtexprvalue>true</rtexprvalue>	109	<rtexprvalue>true</rtexprvalue>
110	</attribute>	110	</attribute>
111	<attribute>	111	<attribute>
112	<name>prefix</name>	112	<name>prefix</name>
113	<required>false</required>	113	<required>false</required>
114	<rtexprvalue>true</rtexprvalue>	114	<rtexprvalue>true</rtexprvalue>
115	</attribute>	115	</attribute>
116	</tag>	116	</tag>
117		117
118	<tag>	118	<tag>
119	<name>setBundle</name>	119	<name>setBundle</name>
120	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetBundleTag</tag-class>	120	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetBundleTag</tag-class>
121	<body-content>empty</body-content>	121	<body-content>empty</body-content>
122	<description>	122	<description>
123	Loads a resource bundle and stores it in the named scoped variable or	123	Loads a resource bundle and stores it in the named scoped variable or
124	the bundle configuration variable	124	the bundle configuration variable
125	</description>	125	</description>
126	<attribute>	126	<attribute>
127	<name>basename</name>	127	<name>basename</name>
128	<required>true</required>	128	<required>true</required>
129	<rtexprvalue>true</rtexprvalue>	129	<rtexprvalue>true</rtexprvalue>
130	</attribute>	130	</attribute>
131	<attribute>	131	<attribute>
132	<name>var</name>	132	<name>var</name>
133	<required>false</required>	133	<required>false</required>
134	<rtexprvalue>false</rtexprvalue>	134	<rtexprvalue>false</rtexprvalue>
135	</attribute>	135	</attribute>
136	<attribute>	136	<attribute>
137	<name>scope</name>	137	<name>scope</name>
138	<required>false</required>	138	<required>false</required>
139	<rtexprvalue>false</rtexprvalue>	139	<rtexprvalue>false</rtexprvalue>
140	</attribute>	140	</attribute>
141	</tag>	141	</tag>
142		142
143	<tag>	143	<tag>
144	<name>message</name>	144	<name>message</name>
145	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.MessageTag</tag-class>	145	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.MessageTag</tag-class>
146	<body-content>JSP</body-content>	146	<body-content>JSP</body-content>
147	<description>	147	<description>
148	Maps key to localized message and performs parametric replacement	148	Maps key to localized message and performs parametric replacement
149	</description>	149	</description>
150	<attribute>	150	<attribute>
151	<name>key</name>	151	<name>key</name>
152	<required>false</required>	152	<required>false</required>
153	<rtexprvalue>true</rtexprvalue>	153	<rtexprvalue>true</rtexprvalue>
154	</attribute>	154	</attribute>
155	<attribute>	155	<attribute>
156	<name>bundle</name>	156	<name>bundle</name>
157	<required>false</required>	157	<required>false</required>
158	<rtexprvalue>true</rtexprvalue>	158	<rtexprvalue>true</rtexprvalue>
159	</attribute>	159	</attribute>
160	<attribute>	160	<attribute>
161	<name>var</name>	161	<name>var</name>
162	<required>false</required>	162	<required>false</required>
163	<rtexprvalue>false</rtexprvalue>	163	<rtexprvalue>false</rtexprvalue>
164	</attribute>	164	</attribute>
165	<attribute>	165	<attribute>
166	<name>scope</name>	166	<name>scope</name>
167	<required>false</required>	167	<required>false</required>
168	<rtexprvalue>false</rtexprvalue>	168	<rtexprvalue>false</rtexprvalue>
169	</attribute>	169	</attribute>
170	</tag>	170	</tag>
171		171
172	<tag>	172	<tag>
173	<name>param</name>	173	<name>param</name>
174	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParamTag</tag-class>	174	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParamTag</tag-class>
175	<body-content>JSP</body-content>	175	<body-content>JSP</body-content>
176	<description>	176	<description>
177	Supplies an argument for parametric replacement to a containing	177	Supplies an argument for parametric replacement to a containing
178	<message> tag	178	<message> tag
179	</description>	179	</description>
180	<attribute>	180	<attribute>
181	<name>value</name>	181	<name>value</name>
182	<required>false</required>	182	<required>false</required>
183	<rtexprvalue>true</rtexprvalue>	183	<rtexprvalue>true</rtexprvalue>
184	</attribute>	184	</attribute>
185	</tag>	185	</tag>
186		186
187	<tag>	187	<tag>
188	<name>formatNumber</name>	188	<name>formatNumber</name>
189	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatNumberTag</tag-class>	189	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatNumberTag</tag-class>
190	<body-content>JSP</body-content>	190	<body-content>JSP</body-content>
191	<description>	191	<description>
192	Formats a numeric value as a number, currency, or percentage	192	Formats a numeric value as a number, currency, or percentage
193	</description>	193	</description>
194	<attribute>	194	<attribute>
195	<name>value</name>	195	<name>value</name>
196	<required>false</required>	196	<required>false</required>
197	<rtexprvalue>true</rtexprvalue>	197	<rtexprvalue>true</rtexprvalue>
198	</attribute>	198	</attribute>
199	<attribute>	199	<attribute>
200	<name>type</name>	200	<name>type</name>
201	<required>false</required>	201	<required>false</required>
202	<rtexprvalue>true</rtexprvalue>	202	<rtexprvalue>true</rtexprvalue>
203	</attribute>	203	</attribute>
204	<attribute>	204	<attribute>
205	<name>pattern</name>	205	<name>pattern</name>
206	<required>false</required>	206	<required>false</required>
207	<rtexprvalue>true</rtexprvalue>	207	<rtexprvalue>true</rtexprvalue>
208	</attribute>	208	</attribute>
209	<attribute>	209	<attribute>
210	<name>currencyCode</name>	210	<name>currencyCode</name>
211	<required>false</required>	211	<required>false</required>
212	<rtexprvalue>true</rtexprvalue>	212	<rtexprvalue>true</rtexprvalue>
213	</attribute>	213	</attribute>
214	<attribute>	214	<attribute>
215	<name>currencySymbol</name>	215	<name>currencySymbol</name>
216	<required>false</required>	216	<required>false</required>
217	<rtexprvalue>true</rtexprvalue>	217	<rtexprvalue>true</rtexprvalue>
218	</attribute>	218	</attribute>
219	<attribute>	219	<attribute>
220	<name>groupingUsed</name>	220	<name>groupingUsed</name>
221	<required>false</required>	221	<required>false</required>
222	<rtexprvalue>true</rtexprvalue>	222	<rtexprvalue>true</rtexprvalue>
223	</attribute>	223	</attribute>
224	<attribute>	224	<attribute>
225	<name>maxIntegerDigits</name>	225	<name>maxIntegerDigits</name>
226	<required>false</required>	226	<required>false</required>
227	<rtexprvalue>true</rtexprvalue>	227	<rtexprvalue>true</rtexprvalue>
228	</attribute>	228	</attribute>
229	<attribute>	229	<attribute>
230	<name>minIntegerDigits</name>	230	<name>minIntegerDigits</name>
231	<required>false</required>	231	<required>false</required>
232	<rtexprvalue>true</rtexprvalue>	232	<rtexprvalue>true</rtexprvalue>
233	</attribute>	233	</attribute>
234	<attribute>	234	<attribute>
235	<name>maxFractionDigits</name>	235	<name>maxFractionDigits</name>
236	<required>false</required>	236	<required>false</required>
237	<rtexprvalue>true</rtexprvalue>	237	<rtexprvalue>true</rtexprvalue>
238	</attribute>	238	</attribute>
239	<attribute>	239	<attribute>
240	<name>minFractionDigits</name>	240	<name>minFractionDigits</name>
241	<required>false</required>	241	<required>false</required>
242	<rtexprvalue>true</rtexprvalue>	242	<rtexprvalue>true</rtexprvalue>
243	</attribute>	243	</attribute>
244	<attribute>	244	<attribute>
245	<name>var</name>	245	<name>var</name>
246	<required>false</required>	246	<required>false</required>
247	<rtexprvalue>false</rtexprvalue>	247	<rtexprvalue>false</rtexprvalue>
248	</attribute>	248	</attribute>
249	<attribute>	249	<attribute>
250	<name>scope</name>	250	<name>scope</name>
251	<required>false</required>	251	<required>false</required>
252	<rtexprvalue>false</rtexprvalue>	252	<rtexprvalue>false</rtexprvalue>
253	</attribute>	253	</attribute>
254	</tag>	254	</tag>
255		255
256	<tag>	256	<tag>
257	<name>parseNumber</name>	257	<name>parseNumber</name>
258	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseNumberTag</tag-class>	258	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseNumberTag</tag-class>
259	<body-content>JSP</body-content>	259	<body-content>JSP</body-content>
260	<description>	260	<description>
261	Parses the string representation of a number, currency, or percentage	261	Parses the string representation of a number, currency, or percentage
262	</description>	262	</description>
263	<attribute>	263	<attribute>
264	<name>value</name>	264	<name>value</name>
265	<required>false</required>	265	<required>false</required>
266	<rtexprvalue>true</rtexprvalue>	266	<rtexprvalue>true</rtexprvalue>
267	</attribute>	267	</attribute>
268	<attribute>	268	<attribute>
269	<name>type</name>	269	<name>type</name>
270	<required>false</required>	270	<required>false</required>
271	<rtexprvalue>true</rtexprvalue>	271	<rtexprvalue>true</rtexprvalue>
272	</attribute>	272	</attribute>
273	<attribute>	273	<attribute>
274	<name>pattern</name>	274	<name>pattern</name>
275	<required>false</required>	275	<required>false</required>
276	<rtexprvalue>true</rtexprvalue>	276	<rtexprvalue>true</rtexprvalue>
277	</attribute>	277	</attribute>
278	<attribute>	278	<attribute>
279	<name>parseLocale</name>	279	<name>parseLocale</name>
280	<required>false</required>	280	<required>false</required>
281	<rtexprvalue>true</rtexprvalue>	281	<rtexprvalue>true</rtexprvalue>
282	</attribute>	282	</attribute>
283	<attribute>	283	<attribute>
284	<name>integerOnly</name>	284	<name>integerOnly</name>
285	<required>false</required>	285	<required>false</required>
286	<rtexprvalue>true</rtexprvalue>	286	<rtexprvalue>true</rtexprvalue>
287	</attribute>	287	</attribute>
288	<attribute>	288	<attribute>
289	<name>var</name>	289	<name>var</name>
290	<required>false</required>	290	<required>false</required>
291	<rtexprvalue>false</rtexprvalue>	291	<rtexprvalue>false</rtexprvalue>
292	</attribute>	292	</attribute>
293	<attribute>	293	<attribute>
294	<name>scope</name>	294	<name>scope</name>
295	<required>false</required>	295	<required>false</required>
296	<rtexprvalue>false</rtexprvalue>	296	<rtexprvalue>false</rtexprvalue>
297	</attribute>	297	</attribute>
298	</tag>	298	</tag>
299		299
300	<tag>	300	<tag>
301	<name>formatDate</name>	301	<name>formatDate</name>
302	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatDateTag</tag-class>	302	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatDateTag</tag-class>
303	<body-content>empty</body-content>	303	<body-content>empty</body-content>
304	<description>	304	<description>
305	Formats a date and/or time using the supplied styles and pattern	305	Formats a date and/or time using the supplied styles and pattern
306	</description>	306	</description>
307	<attribute>	307	<attribute>
308	<name>value</name>	308	<name>value</name>
309	<required>true</required>	309	<required>true</required>
310	<rtexprvalue>true</rtexprvalue>	310	<rtexprvalue>true</rtexprvalue>
311	</attribute>	311	</attribute>
312	<attribute>	312	<attribute>
313	<name>type</name>	313	<name>type</name>
314	<required>false</required>	314	<required>false</required>
315	<rtexprvalue>true</rtexprvalue>	315	<rtexprvalue>true</rtexprvalue>
316	</attribute>	316	</attribute>
317	<attribute>	317	<attribute>
318	<name>dateStyle</name>	318	<name>dateStyle</name>
319	<required>false</required>	319	<required>false</required>
320	<rtexprvalue>true</rtexprvalue>	320	<rtexprvalue>true</rtexprvalue>
321	</attribute>	321	</attribute>
322	<attribute>	322	<attribute>
323	<name>timeStyle</name>	323	<name>timeStyle</name>
324	<required>false</required>	324	<required>false</required>
325	<rtexprvalue>true</rtexprvalue>	325	<rtexprvalue>true</rtexprvalue>
326	</attribute>	326	</attribute>
327	<attribute>	327	<attribute>
328	<name>pattern</name>	328	<name>pattern</name>
329	<required>false</required>	329	<required>false</required>
330	<rtexprvalue>true</rtexprvalue>	330	<rtexprvalue>true</rtexprvalue>
331	</attribute>	331	</attribute>
332	<attribute>	332	<attribute>
333	<name>timeZone</name>	333	<name>timeZone</name>
334	<required>false</required>	334	<required>false</required>
335	<rtexprvalue>true</rtexprvalue>	335	<rtexprvalue>true</rtexprvalue>
336	</attribute>	336	</attribute>
337	<attribute>	337	<attribute>
338	<name>var</name>	338	<name>var</name>
339	<required>false</required>	339	<required>false</required>
340	<rtexprvalue>false</rtexprvalue>	340	<rtexprvalue>false</rtexprvalue>
341	</attribute>	341	</attribute>
342	<attribute>	342	<attribute>
343	<name>scope</name>	343	<name>scope</name>
344	<required>false</required>	344	<required>false</required>
345	<rtexprvalue>false</rtexprvalue>	345	<rtexprvalue>false</rtexprvalue>
346	</attribute>	346	</attribute>
347	</tag>	347	</tag>
348		348
349	<tag>	349	<tag>
350	<name>parseDate</name>	350	<name>parseDate</name>
351	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseDateTag</tag-class>	351	<tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseDateTag</tag-class>
352	<body-content>JSP</body-content>	352	<body-content>JSP</body-content>
353	<description>	353	<description>
354	Parses the string representation of a date and/or time	354	Parses the string representation of a date and/or time
355	</description>	355	</description>
356	<attribute>	356	<attribute>
357	<name>value</name>	357	<name>value</name>
358	<required>false</required>	358	<required>false</required>
359	<rtexprvalue>true</rtexprvalue>	359	<rtexprvalue>true</rtexprvalue>
360	</attribute>	360	</attribute>
361	<attribute>	361	<attribute>
362	<name>type</name>	362	<name>type</name>
363	<required>false</required>	363	<required>false</required>
364	<rtexprvalue>true</rtexprvalue>	364	<rtexprvalue>true</rtexprvalue>
365	</attribute>	365	</attribute>
366	<attribute>	366	<attribute>
367	<name>dateStyle</name>	367	<name>dateStyle</name>
368	<required>false</required>	368	<required>false</required>
369	<rtexprvalue>true</rtexprvalue>	369	<rtexprvalue>true</rtexprvalue>
370	</attribute>	370	</attribute>
371	<attribute>	371	<attribute>
372	<name>timeStyle</name>	372	<name>timeStyle</name>
373	<required>false</required>	373	<required>false</required>
374	<rtexprvalue>true</rtexprvalue>	374	<rtexprvalue>true</rtexprvalue>
375	</attribute>	375	</attribute>
376	<attribute>	376	<attribute>
377	<name>pattern</name>	377	<name>pattern</name>
378	<required>false</required>	378	<required>false</required>
379	<rtexprvalue>true</rtexprvalue>	379	<rtexprvalue>true</rtexprvalue>
380	</attribute>	380	</attribute>
381	<attribute>	381	<attribute>
382	<name>timeZone</name>	382	<name>timeZone</name>
383	<required>false</required>	383	<required>false</required>
384	<rtexprvalue>true</rtexprvalue>	384	<rtexprvalue>true</rtexprvalue>
385	</attribute>	385	</attribute>
386	<attribute>	386	<attribute>
387	<name>parseLocale</name>	387	<name>parseLocale</name>
388	<required>false</required>	388	<required>false</required>
389	<rtexprvalue>true</rtexprvalue>	389	<rtexprvalue>true</rtexprvalue>
390	</attribute>	390	</attribute>
391	<attribute>	391	<attribute>
392	<name>var</name>	392	<name>var</name>
393	<required>false</required>	393	<required>false</required>
394	<rtexprvalue>false</rtexprvalue>	394	<rtexprvalue>false</rtexprvalue>
395	</attribute>	395	</attribute>
396	<attribute>	396	<attribute>
397	<name>scope</name>	397	<name>scope</name>
398	<required>false</required>	398	<required>false</required>
399	<rtexprvalue>false</rtexprvalue>	399	<rtexprvalue>false</rtexprvalue>
400	</attribute>	400	</attribute>
401	</tag>	401	</tag>
402		402
403	</taglib>	403	</taglib>

Lines 1-256 Link Here

(-)src/main/resources/META-INF/x-1_0-rt.tld (-240 / +240 lines)
1	<?xml version="1.0" encoding="ISO-8859-1" ?>	1	<?xml version="1.0" encoding="ISO-8859-1" ?>
2	<!DOCTYPE taglib	2	<!DOCTYPE taglib
3	PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"	3	PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
4	"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">	4	"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
5	<taglib>	5	<taglib>
6	<tlib-version>1.0</tlib-version>	6	<tlib-version>1.0</tlib-version>
7	<jsp-version>1.2</jsp-version>	7	<jsp-version>1.2</jsp-version>
8	<short-name>x_rt</short-name>	8	<short-name>x_rt</short-name>
9	<uri>http://java.sun.com/jstl/xml_rt</uri>	9	<uri>http://java.sun.com/jstl/xml_rt</uri>
10	<display-name>JSTL XML RT</display-name>	10	<display-name>JSTL XML RT</display-name>
11	<description>JSTL 1.0 XML library</description>	11	<description>JSTL 1.0 XML library</description>
12		12
13	<validator>	13	<validator>
14	<validator-class>	14	<validator-class>
15	org.apache.taglibs.standard.tlv.JstlXmlTLV	15	org.apache.taglibs.standard.tlv.JstlXmlTLV
16	</validator-class>	16	</validator-class>
17	<description>	17	<description>
18	Provides validation features for JSTL XML tags.	18	Provides validation features for JSTL XML tags.
19	</description>	19	</description>
20	</validator>	20	</validator>
21		21
22	<tag>	22	<tag>
23	<name>choose</name>	23	<name>choose</name>
24	<tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>	24	<tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
25	<body-content>JSP</body-content>	25	<body-content>JSP</body-content>
26	<description>	26	<description>
27	Simple conditional tag that establishes a context for	27	Simple conditional tag that establishes a context for
28	mutually exclusive conditional operations, marked by	28	mutually exclusive conditional operations, marked by
29	<when> and <otherwise>	29	<when> and <otherwise>
30	</description>	30	</description>
31	</tag>	31	</tag>
32		32
33	<tag>	33	<tag>
34	<name>out</name>	34	<name>out</name>
35	<tag-class>org.apache.taglibs.standard.tag.rt.xml.ExprTag</tag-class>	35	<tag-class>org.apache.taglibs.standard.tag.rt.xml.ExprTag</tag-class>
36	<body-content>empty</body-content>	36	<body-content>empty</body-content>
37	<description>	37	<description>
38	Like <%= ... >, but for XPath expressions.	38	Like <%= ... >, but for XPath expressions.
39	</description>	39	</description>
40	<attribute>	40	<attribute>
41	<name>select</name>	41	<name>select</name>
42	<required>true</required>	42	<required>true</required>
43	<rtexprvalue>false</rtexprvalue>	43	<rtexprvalue>false</rtexprvalue>
44	</attribute>	44	</attribute>
45	<attribute>	45	<attribute>
46	<name>escapeXml</name>	46	<name>escapeXml</name>
47	<required>false</required>	47	<required>false</required>
48	<rtexprvalue>true</rtexprvalue>	48	<rtexprvalue>true</rtexprvalue>
49	</attribute>	49	</attribute>
50	</tag>	50	</tag>
51		51
52	<tag>	52	<tag>
53	<name>if</name>	53	<name>if</name>
54	<tag-class>org.apache.taglibs.standard.tag.common.xml.IfTag</tag-class>	54	<tag-class>org.apache.taglibs.standard.tag.common.xml.IfTag</tag-class>
55	<body-content>JSP</body-content>	55	<body-content>JSP</body-content>
56	<description>	56	<description>
57	XML conditional tag, which evalutes its body if the	57	XML conditional tag, which evalutes its body if the
58	supplied XPath expression evalutes to 'true' as a boolean	58	supplied XPath expression evalutes to 'true' as a boolean
59	</description>	59	</description>
60	<attribute>	60	<attribute>
61	<name>select</name>	61	<name>select</name>
62	<required>true</required>	62	<required>true</required>
63	<rtexprvalue>false</rtexprvalue>	63	<rtexprvalue>false</rtexprvalue>
64	</attribute>	64	</attribute>
65	<attribute>	65	<attribute>
66	<name>var</name>	66	<name>var</name>
67	<required>false</required>	67	<required>false</required>
68	<rtexprvalue>false</rtexprvalue>	68	<rtexprvalue>false</rtexprvalue>
69	</attribute>	69	</attribute>
70	<attribute>	70	<attribute>
71	<name>scope</name>	71	<name>scope</name>
72	<required>false</required>	72	<required>false</required>
73	<rtexprvalue>false</rtexprvalue>	73	<rtexprvalue>false</rtexprvalue>
74	</attribute>	74	</attribute>
75	</tag>	75	</tag>
76		76
77	<tag>	77	<tag>
78	<name>forEach</name>	78	<name>forEach</name>
79	<tag-class>org.apache.taglibs.standard.tag.common.xml.ForEachTag</tag-class>	79	<tag-class>org.apache.taglibs.standard.tag.common.xml.ForEachTag</tag-class>
80	<body-content>JSP</body-content>	80	<body-content>JSP</body-content>
81	<description>	81	<description>
82	XML iteration tag.	82	XML iteration tag.
83	</description>	83	</description>
84	<attribute>	84	<attribute>
85	<name>var</name>	85	<name>var</name>
86	<required>false</required>	86	<required>false</required>
87	<rtexprvalue>false</rtexprvalue>	87	<rtexprvalue>false</rtexprvalue>
88	</attribute>	88	</attribute>
89	<attribute>	89	<attribute>
90	<name>select</name>	90	<name>select</name>
91	<required>true</required>	91	<required>true</required>
92	<rtexprvalue>false</rtexprvalue>	92	<rtexprvalue>false</rtexprvalue>
93	</attribute>	93	</attribute>
94	</tag>	94	</tag>
95		95
96	<tag>	96	<tag>
97	<name>otherwise</name>	97	<name>otherwise</name>
98	<tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>	98	<tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
99	<body-content>JSP</body-content>	99	<body-content>JSP</body-content>
100	<description>	100	<description>
101	Subtag of <choose> that follows <when> tags	101	Subtag of <choose> that follows <when> tags
102	and runs only if all of the prior conditions evaluated to	102	and runs only if all of the prior conditions evaluated to
103	'false'	103	'false'
104	</description>	104	</description>
105	</tag>	105	</tag>
106		106
107	<tag>	107	<tag>
108	<name>param</name>	108	<name>param</name>
109	<tag-class>org.apache.taglibs.standard.tag.rt.xml.ParamTag</tag-class>	109	<tag-class>org.apache.taglibs.standard.tag.rt.xml.ParamTag</tag-class>
110	<body-content>JSP</body-content>	110	<body-content>JSP</body-content>
111	<description>	111	<description>
112	Adds a parameter to a containing 'transform' tag's Transformer	112	Adds a parameter to a containing 'transform' tag's Transformer
113	</description>	113	</description>
114	<attribute>	114	<attribute>
115	<name>name</name>	115	<name>name</name>
116	<required>true</required>	116	<required>true</required>
117	<rtexprvalue>true</rtexprvalue>	117	<rtexprvalue>true</rtexprvalue>
118	</attribute>	118	</attribute>
119	<attribute>	119	<attribute>
120	<name>value</name>	120	<name>value</name>
121	<required>false</required>	121	<required>false</required>
122	<rtexprvalue>true</rtexprvalue>	122	<rtexprvalue>true</rtexprvalue>
123	</attribute>	123	</attribute>
124	</tag>	124	</tag>
125		125
126	<tag>	126	<tag>
127	<name>parse</name>	127	<name>parse</name>
128	<tag-class>org.apache.taglibs.standard.tag.rt.xml.ParseTag</tag-class>	128	<tag-class>org.apache.taglibs.standard.tag.rt.xml.ParseTag</tag-class>
129	<tei-class>org.apache.taglibs.standard.tei.XmlParseTEI</tei-class>	129	<tei-class>org.apache.taglibs.standard.tei.XmlParseTEI</tei-class>
130	<body-content>JSP</body-content>	130	<body-content>JSP</body-content>
131	<description>	131	<description>
132	Parses XML content from 'source' attribute or 'body'	132	Parses XML content from 'source' attribute or 'body'
133	</description>	133	</description>
134	<attribute>	134	<attribute>
135	<name>var</name>	135	<name>var</name>
136	<required>false</required>	136	<required>false</required>
137	<rtexprvalue>false</rtexprvalue>	137	<rtexprvalue>false</rtexprvalue>
138	</attribute>	138	</attribute>
139	<attribute>	139	<attribute>
140	<name>varDom</name>	140	<name>varDom</name>
141	<required>false</required>	141	<required>false</required>
142	<rtexprvalue>false</rtexprvalue>	142	<rtexprvalue>false</rtexprvalue>
143	</attribute>	143	</attribute>
144	<attribute>	144	<attribute>
145	<name>scope</name>	145	<name>scope</name>
146	<required>false</required>	146	<required>false</required>
147	<rtexprvalue>false</rtexprvalue>	147	<rtexprvalue>false</rtexprvalue>
148	</attribute>	148	</attribute>
149	<attribute>	149	<attribute>
150	<name>scopeDom</name>	150	<name>scopeDom</name>
151	<required>false</required>	151	<required>false</required>
152	<rtexprvalue>false</rtexprvalue>	152	<rtexprvalue>false</rtexprvalue>
153	</attribute>	153	</attribute>
154	<attribute>	154	<attribute>
155	<name>xml</name>	155	<name>xml</name>
156	<required>false</required>	156	<required>false</required>
157	<rtexprvalue>true</rtexprvalue>	157	<rtexprvalue>true</rtexprvalue>
158	</attribute>	158	</attribute>
159	<attribute>	159	<attribute>
160	<name>systemId</name>	160	<name>systemId</name>
161	<required>false</required>	161	<required>false</required>
162	<rtexprvalue>true</rtexprvalue>	162	<rtexprvalue>true</rtexprvalue>
163	</attribute>	163	</attribute>
164	<attribute>	164	<attribute>
165	<name>filter</name>	165	<name>filter</name>
166	<required>false</required>	166	<required>false</required>
167	<rtexprvalue>true</rtexprvalue>	167	<rtexprvalue>true</rtexprvalue>
168	</attribute>	168	</attribute>
169	</tag>	169	</tag>
170		170
171	<tag>	171	<tag>
172	<name>set</name>	172	<name>set</name>
173	<tag-class>org.apache.taglibs.standard.tag.common.xml.SetTag</tag-class>	173	<tag-class>org.apache.taglibs.standard.tag.common.xml.SetTag</tag-class>
174	<body-content>empty</body-content>	174	<body-content>empty</body-content>
175	<description>	175	<description>
176	Saves the result of an XPath expression evaluation in a 'scope'	176	Saves the result of an XPath expression evaluation in a 'scope'
177	</description>	177	</description>
178	<attribute>	178	<attribute>
179	<name>var</name>	179	<name>var</name>
180	<required>true</required>	180	<required>true</required>
181	<rtexprvalue>false</rtexprvalue>	181	<rtexprvalue>false</rtexprvalue>
182	</attribute>	182	</attribute>
183	<attribute>	183	<attribute>
184	<name>select</name>	184	<name>select</name>
185	<required>false</required>	185	<required>false</required>
186	<rtexprvalue>false</rtexprvalue>	186	<rtexprvalue>false</rtexprvalue>
187	</attribute>	187	</attribute>
188	<attribute>	188	<attribute>
189	<name>scope</name>	189	<name>scope</name>
190	<required>false</required>	190	<required>false</required>
191	<rtexprvalue>false</rtexprvalue>	191	<rtexprvalue>false</rtexprvalue>
192	</attribute>	192	</attribute>
193	</tag>	193	</tag>
194		194
195	<tag>	195	<tag>
196	<name>transform</name>	196	<name>transform</name>
197	<tag-class>org.apache.taglibs.standard.tag.rt.xml.TransformTag</tag-class>	197	<tag-class>org.apache.taglibs.standard.tag.rt.xml.TransformTag</tag-class>
198	<tei-class>org.apache.taglibs.standard.tei.XmlTransformTEI</tei-class>	198	<tei-class>org.apache.taglibs.standard.tei.XmlTransformTEI</tei-class>
199	<body-content>JSP</body-content>	199	<body-content>JSP</body-content>
200	<description>	200	<description>
201	Conducts a transformation given a source XML document	201	Conducts a transformation given a source XML document
202	and an XSLT stylesheet	202	and an XSLT stylesheet
203	</description>	203	</description>
204	<attribute>	204	<attribute>
205	<name>var</name>	205	<name>var</name>
206	<required>false</required>	206	<required>false</required>
207	<rtexprvalue>false</rtexprvalue>	207	<rtexprvalue>false</rtexprvalue>
208	</attribute>	208	</attribute>
209	<attribute>	209	<attribute>
210	<name>scope</name>	210	<name>scope</name>
211	<required>false</required>	211	<required>false</required>
212	<rtexprvalue>false</rtexprvalue>	212	<rtexprvalue>false</rtexprvalue>
213	</attribute>	213	</attribute>
214	<attribute>	214	<attribute>
215	<name>result</name>	215	<name>result</name>
216	<required>false</required>	216	<required>false</required>
217	<rtexprvalue>true</rtexprvalue>	217	<rtexprvalue>true</rtexprvalue>
218	</attribute>	218	</attribute>
219	<attribute>	219	<attribute>
220	<name>xml</name>	220	<name>xml</name>
221	<required>false</required>	221	<required>false</required>
222	<rtexprvalue>true</rtexprvalue>	222	<rtexprvalue>true</rtexprvalue>
223	</attribute>	223	</attribute>
224	<attribute>	224	<attribute>
225	<name>xmlSystemId</name>	225	<name>xmlSystemId</name>
226	<required>false</required>	226	<required>false</required>
227	<rtexprvalue>true</rtexprvalue>	227	<rtexprvalue>true</rtexprvalue>
228	</attribute>	228	</attribute>
229	<attribute>	229	<attribute>
230	<name>xslt</name>	230	<name>xslt</name>
231	<required>false</required>	231	<required>false</required>
232	<rtexprvalue>true</rtexprvalue>	232	<rtexprvalue>true</rtexprvalue>
233	</attribute>	233	</attribute>
234	<attribute>	234	<attribute>
235	<name>xsltSystemId</name>	235	<name>xsltSystemId</name>
236	<required>false</required>	236	<required>false</required>
237	<rtexprvalue>true</rtexprvalue>	237	<rtexprvalue>true</rtexprvalue>
238	</attribute>	238	</attribute>
239	</tag>	239	</tag>
240		240
241	<tag>	241	<tag>
242	<name>when</name>	242	<name>when</name>
243	<tag-class>org.apache.taglibs.standard.tag.common.xml.WhenTag</tag-class>	243	<tag-class>org.apache.taglibs.standard.tag.common.xml.WhenTag</tag-class>
244	<body-content>JSP</body-content>	244	<body-content>JSP</body-content>
245	<description>	245	<description>
246	Subtag of <choose> that includes its body if its	246	Subtag of <choose> that includes its body if its
247	expression evalutes to 'true'	247	expression evalutes to 'true'
248	</description>	248	</description>
249	<attribute>	249	<attribute>
250	<name>select</name>	250	<name>select</name>
251	<required>true</required>	251	<required>true</required>
252	<rtexprvalue>false</rtexprvalue>	252	<rtexprvalue>false</rtexprvalue>
253	</attribute>	253	</attribute>
254	</tag>	254	</tag>
255		255
256	</taglib>	256	</taglib>

Lines 20-176 Link Here

(-)pom.xml (-140 / +181 lines)
20	Enable Cactus tests	20	Enable Cactus tests
21	-->	21	-->
22	<project	22	<project
23	xmlns="http://maven.apache.org/POM/4.0.0"	23	xmlns="http://maven.apache.org/POM/4.0.0"
24	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"	24	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
25	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">	25	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
26	<modelVersion>4.0.0</modelVersion>	26	<modelVersion>4.0.0</modelVersion>
27	<parent>	27	<parent>
28	<groupId>org.apache.taglibs</groupId>	28	<groupId>org.apache.taglibs</groupId>
29	<artifactId>taglibs-parent</artifactId>	29	<artifactId>taglibs-parent</artifactId>
30	<version>1-SNAPSHOT</version>	30	<version>1-SNAPSHOT</version>
31	</parent>	31	</parent>
32		32
33	<artifactId>taglibs-standard-impl</artifactId>	33	<artifactId>taglibs-standard-impl</artifactId>
34	<version>1.2-SNAPSHOT</version>	34	<version>1.2-SNAPSHOT</version>
35	<packaging>bundle</packaging>	35	<packaging>bundle</packaging>
36		36
37	<name>Apache Standard Taglib - JSTL Implementation</name>	37	<name>Apache Standard Taglib - JSTL Implementation</name>
38		38
39	<inceptionYear>2001</inceptionYear>	39	<inceptionYear>2001</inceptionYear>
40	<description>	40	<description>
41	An implementation of the JSP Standard Tag Library (JSTL).	41	An implementation of the JSP Standard Tag Library (JSTL).
42	</description>	42	</description>
43		43
44	<url>http://tomcat.apache.org/taglibs/standard/</url>	44	<url>http://tomcat.apache.org/taglibs/standard/</url>
45		45
46	<scm>	46	<scm>
47	<connection>scm:svn:http://svn.apache.org/repos/asf/tomcat/taglibs/standard/trunk/impl</connection>	47	<connection>scm:svn:http://svn.apache.org/repos/asf/tomcat/taglibs/standard/trunk/impl</connection>
48	<developerConnection>scm:svn:https://svn.apache.org/repos/asf/tomcat/taglibs/standard/trunk/impl</developerConnection>	48	<developerConnection>scm:svn:https://svn.apache.org/repos/asf/tomcat/taglibs/standard/trunk/impl
49	<url>http://svn.apache.org/viewvc/tomcat/taglibs/standard/trunk/impl</url>	49	</developerConnection>
50	</scm>	50	<url>http://svn.apache.org/viewvc/tomcat/taglibs/standard/trunk/impl</url>
		51	</scm>
51		52
52	<developers>	53	<developers>
53	<developer><name>Pierre Delisle</name></developer>	54	<developer>
54	<developer><name>Shawn Bayern</name></developer>	55	<name>Pierre Delisle</name>
55	<developer><name>Nathan Abramson</name></developer>	56	</developer>
56	<developer><name>Hans Bergsten</name></developer>	57	<developer>
57	<developer><name>Scott Hasse</name></developer>	58	<name>Shawn Bayern</name>
58	<developer><name>Justyna Horwat</name></developer>	59	</developer>
59	<developer><name>Mark Kolb</name></developer>	60	<developer>
60	<developer><name>Jan Luehe</name></developer>	61	<name>Nathan Abramson</name>
61	<developer><name>Glenn Nielsen</name></developer>	62	</developer>
62	<developer><name>Dmitri Plotnikov</name></developer>	63	<developer>
63	<developer><name>Felipe Leme</name></developer>	64	<name>Hans Bergsten</name>
64	<developer><name>Henri Yandell</name></developer>	65	</developer>
65	<developer><name>Bjorn Townsend</name></developer>	66	<developer>
66	</developers>	67	<name>Scott Hasse</name>
		68	</developer>
		69	<developer>
		70	<name>Justyna Horwat</name>
		71	</developer>
		72	<developer>
		73	<name>Mark Kolb</name>
		74	</developer>
		75	<developer>
		76	<name>Jan Luehe</name>
		77	</developer>
		78	<developer>
		79	<name>Glenn Nielsen</name>
		80	</developer>
		81	<developer>
		82	<name>Dmitri Plotnikov</name>
		83	</developer>
		84	<developer>
		85	<name>Felipe Leme</name>
		86	</developer>
		87	<developer>
		88	<name>Henri Yandell</name>
		89	</developer>
		90	<developer>
		91	<name>Bjorn Townsend</name>
		92	</developer>
		93	</developers>
67		94
68	<contributors>	95	<contributors>
69	<contributor><name>Robert Goff</name></contributor>	96	<contributor>
70	</contributors>	97	<name>Robert Goff</name>
		98	</contributor>
		99	</contributors>
71		100
72	<dependencies>	101	<dependencies>
73	<dependency>	102	<dependency>
74	<groupId>org.apache.taglibs</groupId>	103	<groupId>org.apache.taglibs</groupId>
75	<artifactId>taglibs-standard-spec</artifactId>	104	<artifactId>taglibs-standard-spec</artifactId>
76	<version>1.2-SNAPSHOT</version>	105	<version>1.2-SNAPSHOT</version>
77	<scope>provided</scope>	106	<scope>provided</scope>
78	</dependency>	107	</dependency>
79		108
80	<dependency>	109	<dependency>
81	<groupId>javax.servlet</groupId>	110	<groupId>javax.servlet</groupId>
82	<artifactId>servlet-api</artifactId>	111	<artifactId>servlet-api</artifactId>
83	<version>2.5</version>	112	<version>2.5</version>
84	<scope>provided</scope>	113	<scope>provided</scope>
85	</dependency>	114	</dependency>
86	<dependency>	115	<dependency>
87	<groupId>javax.servlet.jsp</groupId>	116	<groupId>javax.servlet.jsp</groupId>
88	<artifactId>jsp-api</artifactId>	117	<artifactId>jsp-api</artifactId>
89	<version>2.1</version>	118	<version>2.1</version>
90	<scope>provided</scope>	119	<scope>provided</scope>
91	</dependency>	120	</dependency>
92	<dependency>	121	<dependency>
93	<groupId>javax.el</groupId>	122	<groupId>javax.el</groupId>
94	<artifactId>el-api</artifactId>	123	<artifactId>el-api</artifactId>
95	<version>1.0</version>	124	<version>1.0</version>
96	<scope>provided</scope>	125	<scope>provided</scope>
97	</dependency>	126	</dependency>
98	<dependency>	127	<dependency>
99	<groupId>xalan</groupId>	128	<groupId>xalan</groupId>
100	<artifactId>xalan</artifactId>	129	<artifactId>xalan</artifactId>
101	<version>2.7.1</version>	130	<version>2.7.1</version>
102	<scope>provided</scope>	131	<scope>provided</scope>
103	</dependency>	132	</dependency>
104		133
105	<dependency>	134	<dependency>
106	<groupId>junit</groupId>	135	<groupId>junit</groupId>
107	<artifactId>junit</artifactId>	136	<artifactId>junit</artifactId>
108	<version>4.8.1</version>	137	<version>4.8.1</version>
109	<scope>test</scope>	138	<scope>test</scope>
110	</dependency>	139	</dependency>
111	<dependency>	140	<dependency>
112	<groupId>org.easymock</groupId>	141	<groupId>org.easymock</groupId>
113	<artifactId>easymock</artifactId>	142	<artifactId>easymock</artifactId>
114	<version>3.0</version>	143	<version>3.0</version>
115	<scope>test</scope>	144	<scope>test</scope>
116	</dependency>	145	</dependency>
117	</dependencies>	146	</dependencies>
118		147
119	<build>	148	<build>
120	<plugins>	149	<plugins>
121	<plugin>	150	<plugin>
122	<groupId>org.apache.felix</groupId>	151	<groupId>org.apache.felix</groupId>
123	<artifactId>maven-bundle-plugin</artifactId>	152	<artifactId>maven-bundle-plugin</artifactId>
124	<configuration>	153	<configuration>
125	<excludeDependencies>true</excludeDependencies>	154	<excludeDependencies>true</excludeDependencies>
126	<instructions>	155	<instructions>
127	<Export-Package>*;version="1.2"</Export-Package>	156	<Export-Package>*;version="1.2"</Export-Package>
128	<Import-Package>org.apache.x;resolution:=optional,</Import-Package>	157	<Import-Package>org.apache.x;resolution:=optional,</Import-Package>
129	</instructions>	158	</instructions>
130	</configuration>	159	</configuration>
131	</plugin>	160	</plugin>
132	</plugins>	161	</plugins>
133	</build>	162	</build>
134
135	<reporting>
136	<plugins>
137	<plugin>
138	<artifactId>maven-pmd-plugin</artifactId>
139	<version>2.3</version>
140	<configuration>
141	<targetJdk>${maven.compiler.target}</targetJdk>
142	</configuration>
143	<reportSets>
144	<reportSet>
145	<reports>
146	<report>pmd</report>
147	<report>cpd</report>
148	</reports>
149	</reportSet>
150	</reportSets>
151	</plugin>
152	<plugin>
153	<groupId>org.codehaus.mojo</groupId>
154	<artifactId>taglist-maven-plugin</artifactId>
155	<version>2.4</version>
156	</plugin>
157	<plugin>
158	<groupId>org.codehaus.mojo</groupId>
159	<artifactId>javancss-maven-plugin</artifactId>
160	<version>2.0</version>
161	</plugin>
162	<plugin>
163	<groupId>org.codehaus.mojo</groupId>
164	<artifactId>findbugs-maven-plugin</artifactId>
165	<version>1.2</version>
166	<configuration>
167	<threshold>Normal</threshold>
168	<effort>Default</effort>
169	<!-- <excludeFilterFile>${basedir}/findbugs-exclude-filter.xml</excludeFilterFile> -->
170	</configuration>
171	</plugin>
172	</plugins>
173	</reporting>
174		163
		164	<reporting>
		165	<plugins>
		166	<plugin>
		167	<groupId>org.codehaus.mojo</groupId>
		168	<artifactId>jxr-maven-plugin</artifactId>
		169	</plugin>
		170	<plugin>
		171	<artifactId>maven-pmd-plugin</artifactId>
		172	<version>2.3</version>
		173	<configuration>
		174	<targetJdk>${maven.compiler.target}</targetJdk>
		175	</configuration>
		176	<reportSets>
		177	<reportSet>
		178	<reports>
		179	<report>pmd</report>
		180	<report>cpd</report>
		181	</reports>
		182	</reportSet>
		183	</reportSets>
		184	</plugin>
		185	<plugin>
		186	<groupId>org.codehaus.mojo</groupId>
		187	<artifactId>taglist-maven-plugin</artifactId>
		188	<version>2.4</version>
		189	</plugin>
		190	<plugin>
		191	<groupId>org.codehaus.mojo</groupId>
		192	<artifactId>javancss-maven-plugin</artifactId>
		193	<version>2.0</version>
		194	</plugin>
		195	<plugin>
		196	<groupId>org.codehaus.mojo</groupId>
		197	<artifactId>findbugs-maven-plugin</artifactId>
		198	<version>1.2</version>
		199	<configuration>
		200	<threshold>Normal</threshold>
		201	<effort>Default</effort>
		202	<!-- <excludeFilterFile>${basedir}/findbugs-exclude-filter.xml</excludeFilterFile> -->
		203	</configuration>
		204	</plugin>
		205	<plugin>
		206	<groupId>org.apache.maven.plugins</groupId>
		207	<artifactId>maven-checkstyle-plugin</artifactId>
		208	<version>2.6</version>
		209	<configuration>
		210	<configLocation>checkstyle.xml</configLocation>
		211	</configuration>
		212	</plugin>
		213	</plugins>
		214	</reporting>
175		215
		216
176	</project>	217	</project>