diff --git a/tomcat-uid/webapps/examples/jsp/cal/Entries.java.html b/tomcat-uid/webapps/examples/jsp/cal/Entries.java.html
new file mode 100644
index 0000000..6093d31
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/cal/Entries.java.html
@@ -0,0 +1,74 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package cal;
+
+import java.util.Hashtable;
+import javax.servlet.http.*;
+
+public class Entries {
+
+  private Hashtable entries;
+  private static final String[] time = {"8am", "9am", "10am", "11am", "12pm", 
+					"1pm", "2pm", "3pm", "4pm", "5pm", "6pm",
+					"7pm", "8pm" };
+  public static final int rows = 12;
+
+  public Entries () {   
+   entries = new Hashtable (rows);
+   for (int i=0; i &lt; rows; i++) {
+     entries.put (time[i], new Entry(time[i]));
+   }
+  }
+
+  public int getRows () {
+    return rows;
+  }
+
+  public Entry getEntry (int index) {
+    return (Entry)this.entries.get(time[index]);
+  }
+
+  public int getIndex (String tm) {
+    for (int i=0; i&lt;rows; i++)
+      if(tm.equals(time[i])) return i;
+    return -1;
+  }
+
+  public void processRequest (HttpServletRequest request, String tm) {
+    int index = getIndex (tm);
+    if (index >= 0) {
+      String descr = request.getParameter ("description");
+      ((Entry)entries.get(time[index])).setDescription (descr);
+    }
+  }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/cal/Entry.java.html b/tomcat-uid/webapps/examples/jsp/cal/Entry.java.html
new file mode 100644
index 0000000..f982750
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/cal/Entry.java.html
@@ -0,0 +1,57 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package cal;
+
+public class Entry {
+
+  String hour;
+  String description;
+  String color;
+
+  public Entry (String hour) {
+    this.hour = hour;
+    this.description = "";
+
+  }
+
+  public String getHour () {
+    return this.hour;
+  }
+
+  public String getColor () {
+    if (description.equals("")) return "lightblue";
+    else return "red";
+  }
+
+  public String getDescription () {
+    if (description.equals("")) return "None";
+    else return this.description;
+  }
+
+  public void setDescription (String descr) {
+    description = descr;
+  }
+ 
+}
+
+
+
+
+
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/cal/JspCalendar.java.html b/tomcat-uid/webapps/examples/jsp/cal/JspCalendar.java.html
new file mode 100644
index 0000000..e1b4b83
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/cal/JspCalendar.java.html
@@ -0,0 +1,156 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package cal;
+
+import java.util.*;
+
+public class JspCalendar {
+    Calendar  calendar = null;
+    Date currentDate;
+
+    public JspCalendar() {
+	calendar = Calendar.getInstance();
+	Date trialTime = new Date();
+	calendar.setTime(trialTime);
+    }
+
+
+    public int getYear() {
+	return calendar.get(Calendar.YEAR);
+    }
+    
+    public String getMonth() {
+	int m = getMonthInt();
+	String[] months = new String [] { "January", "February", "March",
+					"April", "May", "June",
+					"July", "August", "September",
+					"October", "November", "December" };
+	if (m > 12)
+	    return "Unknown to Man";
+	
+	return months[m - 1];
+
+    }
+
+    public String getDay() {
+	int x = getDayOfWeek();
+	String[] days = new String[] {"Sunday", "Monday", "Tuesday", "Wednesday", 
+				      "Thursday", "Friday", "Saturday"};
+
+	if (x > 7)
+	    return "Unknown to Man";
+
+	return days[x - 1];
+
+    }
+    
+    public int getMonthInt() {
+	return 1 + calendar.get(Calendar.MONTH);
+    }
+
+    public String getDate() {
+	return getMonthInt() + "/" + getDayOfMonth() + "/" +  getYear();	
+    }
+
+    public String getCurrentDate() {
+        Date dt = new Date ();
+	calendar.setTime (dt);
+	return getMonthInt() + "/" + getDayOfMonth() + "/" +  getYear();
+
+    }
+
+    public String getNextDate() {
+        calendar.set (Calendar.DAY_OF_MONTH, getDayOfMonth() + 1);
+	return getDate ();
+    }
+
+    public String getPrevDate() {
+        calendar.set (Calendar.DAY_OF_MONTH, getDayOfMonth() - 1);
+	return getDate ();
+    }
+
+    public String getTime() {
+	return getHour() + ":" + getMinute() + ":" + getSecond();
+    }
+
+    public int getDayOfMonth() {
+	return calendar.get(Calendar.DAY_OF_MONTH);
+    }
+
+    public int getDayOfYear() {
+	return calendar.get(Calendar.DAY_OF_YEAR);
+    }
+
+    public int getWeekOfYear() {
+	return calendar.get(Calendar.WEEK_OF_YEAR);
+    }
+
+    public int getWeekOfMonth() {
+	return calendar.get(Calendar.WEEK_OF_MONTH);
+    }
+
+    public int getDayOfWeek() {
+	return calendar.get(Calendar.DAY_OF_WEEK);
+    }
+     
+    public int getHour() {
+	return calendar.get(Calendar.HOUR_OF_DAY);
+    }
+    
+    public int getMinute() {
+	return calendar.get(Calendar.MINUTE);
+    }
+
+
+    public int getSecond() {
+	return calendar.get(Calendar.SECOND);
+    }
+
+  
+    public int getEra() {
+	return calendar.get(Calendar.ERA);
+    }
+
+    public String getUSTimeZone() {
+	String[] zones = new String[] {"Hawaii", "Alaskan", "Pacific",
+				       "Mountain", "Central", "Eastern"};
+	
+	return zones[10 + getZoneOffset()];
+    }
+
+    public int getZoneOffset() {
+	return calendar.get(Calendar.ZONE_OFFSET)/(60*60*1000);
+    }
+
+
+    public int getDSTOffset() {
+	return calendar.get(Calendar.DST_OFFSET)/(60*60*1000);
+    }
+
+    
+    public int getAMPM() {
+	return calendar.get(Calendar.AM_PM);
+    }
+}
+
+
+
+
+
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/cal/TableBean.java.html b/tomcat-uid/webapps/examples/jsp/cal/TableBean.java.html
new file mode 100644
index 0000000..a81a66b
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/cal/TableBean.java.html
@@ -0,0 +1,102 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package cal;
+
+import javax.servlet.http.*;
+import java.util.Hashtable;
+
+public class TableBean {
+
+  Hashtable table;
+  JspCalendar JspCal;
+  Entries entries;
+  String date;
+  String name = null;
+  String email = null;
+  boolean processError = false;
+
+  public TableBean () {
+    this.table = new Hashtable (10);
+    this.JspCal = new JspCalendar ();
+    this.date = JspCal.getCurrentDate ();
+  }
+
+  public void setName (String nm) {
+    this.name = nm;
+  }
+
+  public String getName () {
+    return this.name;
+  }
+  
+  public void setEmail (String mail) {
+    this.email = mail;
+  }
+
+  public String getEmail () {
+    return this.email;
+  }
+
+  public String getDate () {
+    return this.date;
+  }
+
+  public Entries getEntries () {
+    return this.entries;
+  }
+
+  public void processRequest (HttpServletRequest request) {
+
+    // Get the name and e-mail.
+    this.processError = false;
+    if (name == null || name.equals("")) setName(request.getParameter ("name"));  
+    if (email == null || email.equals("")) setEmail(request.getParameter ("email"));
+    if (name == null || email == null ||
+		name.equals("") || email.equals("")) {
+      this.processError = true;
+      return;
+    }
+
+    // Get the date.
+    String dateR = request.getParameter ("date");
+    if (dateR == null) date = JspCal.getCurrentDate ();
+    else if (dateR.equalsIgnoreCase("next")) date = JspCal.getNextDate ();
+    else if (dateR.equalsIgnoreCase("prev")) date = JspCal.getPrevDate ();
+
+    entries = (Entries) table.get (date);
+    if (entries == null) {
+      entries = new Entries ();
+      table.put (date, entries);
+    }
+
+    // If time is provided add the event.
+	String time = request.getParameter("time");
+    if (time != null) entries.processRequest (request, time);
+  }
+
+  public boolean getProcessError () {
+    return this.processError;
+  }
+}
+
+
+
+
+
+
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/cal/cal1.jsp b/tomcat-uid/webapps/examples/jsp/cal/cal1.jsp
new file mode 100644
index 0000000..a691df4
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/cal/cal1.jsp
@@ -0,0 +1,95 @@
+<HTML>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<HEAD><TITLE> 
+	Calendar: A JSP APPLICATION
+</TITLE></HEAD>
+
+
+<BODY BGCOLOR="white">
+
+<%@ page language="java" import="cal.*" %>
+<jsp:useBean id="table" scope="session" class="cal.TableBean" />
+
+<%
+	table.processRequest(request);
+	if (table.getProcessError() == false) {
+%>
+
+<!-- html table goes here -->
+<CENTER>
+<TABLE WIDTH=60% BGCOLOR=yellow CELLPADDING=15>
+<TR>
+<TD ALIGN=CENTER> <A HREF=cal1.jsp?date=prev> prev </A>
+<TD ALIGN=CENTER> Calendar:<%= table.getDate() %></TD>
+<TD ALIGN=CENTER> <A HREF=cal1.jsp?date=next> next </A>
+</TR>
+</TABLE>
+
+<!-- the main table -->
+<TABLE WIDTH=60% BGCOLOR=lightblue BORDER=1 CELLPADDING=10>
+<TR>
+<TH> Time </TH>
+<TH> Appointment </TH>
+</TR>
+<FORM METHOD=POST ACTION=cal1.jsp>
+<%
+	for(int i=0; i<table.getEntries().getRows(); i++) {
+	   cal.Entry entr = table.getEntries().getEntry(i);	
+%>
+	<TR>
+	<TD> 
+	<A HREF=cal2.jsp?time=<%= entr.getHour() %>>
+		<%= entr.getHour() %> </A>
+	</TD>
+	<TD BGCOLOR=<%= entr.getColor() %>>
+	<% out.print(util.HTMLFilter.filter(entr.getDescription())); %>
+	</TD> 
+	</TR>
+<%
+	}
+%>
+</FORM>
+</TABLE>
+<BR>
+
+<!-- footer -->
+<TABLE WIDTH=60% BGCOLOR=yellow CELLPADDING=15>
+<TR>
+<TD ALIGN=CENTER>  <% out.print(util.HTMLFilter.filter(table.getName())); %> : 
+		     <% out.print(util.HTMLFilter.filter(table.getEmail())); %> </TD>
+</TR>
+</TABLE>
+</CENTER>
+
+<%
+	} else {
+%>
+<font size=5>
+	You must enter your name and email address correctly.
+</font>
+<%
+	}
+%>
+
+
+</BODY>
+</HTML>
+
+
+
+
diff --git a/tomcat-uid/webapps/examples/jsp/cal/cal1.jsp.html b/tomcat-uid/webapps/examples/jsp/cal/cal1.jsp.html
new file mode 100644
index 0000000..f9c3689
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/cal/cal1.jsp.html
@@ -0,0 +1,97 @@
+<html><body><pre>
+&lt;HTML>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;HEAD>&lt;TITLE> 
+	Calendar: A JSP APPLICATION
+&lt;/TITLE>&lt;/HEAD>
+
+
+&lt;BODY BGCOLOR="white">
+
+&lt;%@ page language="java" import="cal.*" %>
+&lt;jsp:useBean id="table" scope="session" class="cal.TableBean" />
+
+&lt;%
+	table.processRequest(request);
+	if (table.getProcessError() == false) {
+%>
+
+&lt;!-- html table goes here -->
+&lt;CENTER>
+&lt;TABLE WIDTH=60% BGCOLOR=yellow CELLPADDING=15>
+&lt;TR>
+&lt;TD ALIGN=CENTER> &lt;A HREF=cal1.jsp?date=prev> prev &lt;/A>
+&lt;TD ALIGN=CENTER> Calendar:&lt;%= table.getDate() %>&lt;/TD>
+&lt;TD ALIGN=CENTER> &lt;A HREF=cal1.jsp?date=next> next &lt;/A>
+&lt;/TR>
+&lt;/TABLE>
+
+&lt;!-- the main table -->
+&lt;TABLE WIDTH=60% BGCOLOR=lightblue BORDER=1 CELLPADDING=10>
+&lt;TR>
+&lt;TH> Time &lt;/TH>
+&lt;TH> Appointment &lt;/TH>
+&lt;/TR>
+&lt;FORM METHOD=POST ACTION=cal1.jsp>
+&lt;%
+	for(int i=0; i&lt;table.getEntries().getRows(); i++) {
+	   cal.Entry entr = table.getEntries().getEntry(i);	
+%>
+	&lt;TR>
+	&lt;TD> 
+	&lt;A HREF=cal2.jsp?time=&lt;%= entr.getHour() %>>
+		&lt;%= entr.getHour() %> &lt;/A>
+	&lt;/TD>
+	&lt;TD BGCOLOR=&lt;%= entr.getColor() %>>
+	&lt;% out.print(util.HTMLFilter.filter(entr.getDescription())); %>
+	&lt;/TD> 
+	&lt;/TR>
+&lt;%
+	}
+%>
+&lt;/FORM>
+&lt;/TABLE>
+&lt;BR>
+
+&lt;!-- footer -->
+&lt;TABLE WIDTH=60% BGCOLOR=yellow CELLPADDING=15>
+&lt;TR>
+&lt;TD ALIGN=CENTER>  &lt;% out.print(util.HTMLFilter.filter(table.getName())); %> : 
+		     &lt;% out.print(util.HTMLFilter.filter(table.getEmail())); %> &lt;/TD>
+&lt;/TR>
+&lt;/TABLE>
+&lt;/CENTER>
+
+&lt;%
+	} else {
+%>
+&lt;font size=5>
+	You must enter your name and email address correctly.
+&lt;/font>
+&lt;%
+	}
+%>
+
+
+&lt;/BODY>
+&lt;/HTML>
+
+
+
+
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/cal/cal2.jsp b/tomcat-uid/webapps/examples/jsp/cal/cal2.jsp
new file mode 100644
index 0000000..b6d435b
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/cal/cal2.jsp
@@ -0,0 +1,45 @@
+<HTML>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<HEAD><TITLE> 
+	Calendar: A JSP APPLICATION
+</TITLE></HEAD>
+
+
+<BODY BGCOLOR="white">
+<jsp:useBean id="table" scope="session" class="cal.TableBean" />
+
+<% 
+	String time = request.getParameter ("time");
+%>
+
+<FONT SIZE=5> Please add the following event:
+<BR> <h3> Date <%= table.getDate() %>
+<BR> Time <%= util.HTMLFilter.filter(time) %> </h3>
+</FONT>
+<FORM METHOD=POST ACTION=cal1.jsp>
+<BR> 
+<BR> <INPUT NAME="date" TYPE=HIDDEN VALUE="current">
+<BR> <INPUT NAME="time" TYPE=HIDDEN VALUE="<%= util.HTMLFilter.filter(time) %>">
+<BR> <h2> Description of the event <INPUT NAME="description" TYPE=TEXT SIZE=20> </h2>
+<BR> <INPUT TYPE=SUBMIT VALUE="submit">
+</FORM>
+
+</BODY>
+</HTML>
+
diff --git a/tomcat-uid/webapps/examples/jsp/cal/cal2.jsp.html b/tomcat-uid/webapps/examples/jsp/cal/cal2.jsp.html
new file mode 100644
index 0000000..2548ce7
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/cal/cal2.jsp.html
@@ -0,0 +1,47 @@
+<html><body><pre>
+&lt;HTML>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;HEAD>&lt;TITLE> 
+	Calendar: A JSP APPLICATION
+&lt;/TITLE>&lt;/HEAD>
+
+
+&lt;BODY BGCOLOR="white">
+&lt;jsp:useBean id="table" scope="session" class="cal.TableBean" />
+
+&lt;% 
+	String time = request.getParameter ("time");
+%>
+
+&lt;FONT SIZE=5> Please add the following event:
+&lt;BR> &lt;h3> Date &lt;%= table.getDate() %>
+&lt;BR> Time &lt;%= util.HTMLFilter.filter(time) %> &lt;/h3>
+&lt;/FONT>
+&lt;FORM METHOD=POST ACTION=cal1.jsp>
+&lt;BR> 
+&lt;BR> &lt;INPUT NAME="date" TYPE=HIDDEN VALUE="current">
+&lt;BR> &lt;INPUT NAME="time" TYPE=HIDDEN VALUE="&lt;%= util.HTMLFilter.filter(time) %>">
+&lt;BR> &lt;h2> Description of the event &lt;INPUT NAME="description" TYPE=TEXT SIZE=20> &lt;/h2>
+&lt;BR> &lt;INPUT TYPE=SUBMIT VALUE="submit">
+&lt;/FORM>
+
+&lt;/BODY>
+&lt;/HTML>
+
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/cal/calendar.html b/tomcat-uid/webapps/examples/jsp/cal/calendar.html
new file mode 100644
index 0000000..d77cea5
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/cal/calendar.html
@@ -0,0 +1,43 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="login.html"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h2> Source Code for Calendar Example. <br>
+<h3><a href="cal1.jsp.html">cal1.jsp<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="cal2.jsp.html">cal2.jsp<font color="#0000FF"></a>
+  </font> </h3>
+
+<br>
+<h2> Beans.
+<h3><a href="TableBean.java.html">TableBean<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="Entries.java.html">Entries<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="Entry.java.html">Entry<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/cal/login.html b/tomcat-uid/webapps/examples/jsp/cal/login.html
new file mode 100644
index 0000000..398b39b
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/cal/login.html
@@ -0,0 +1,47 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+	<title> Login page for the calendar. </title>
+</head>
+
+<body bgcolor="white">
+<center>
+
+	<font size=7 color="red"> Please Enter the following information: </font>
+
+<br>
+	<form method=GET action=cal1.jsp>
+
+		<font size=5> Name <input type=text name="name" size=20>
+		</font>
+		<br>
+		<font size=5> Email <input type=text name="email" size=20>
+		</font>
+		<br>
+		<input type=submit name=action value="Submit">
+
+	</form>
+<hr>
+<font size=3 color="red"> Note: This application does not implement the complete 
+functionality of a typical calendar application. It demonstrates a way JSP can be 
+used with html tables and forms.</font>
+
+</center>
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/chat/index.jsp b/tomcat-uid/webapps/examples/jsp/chat/index.jsp
new file mode 100644
index 0000000..b7bc0d0
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/chat/index.jsp
@@ -0,0 +1,32 @@
+<%@page contentType="text/html; charset=UTF-8" %>
+<% if (session.getAttribute("nickname") == null) {
+    response.sendRedirect("login.jsp");
+    return;
+}
+%>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+   <title>JSP Chat</title>
+</head>
+<frameset rows="1*,4*">
+  <frame name="post" src="post.jsp" scrolling="no" title="Post message">
+  <frame name="chat" src="chat" scrolling="yes" title="Chat">
+</frameset>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/chat/index.jsp.html b/tomcat-uid/webapps/examples/jsp/chat/index.jsp.html
new file mode 100644
index 0000000..0b98ebf
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/chat/index.jsp.html
@@ -0,0 +1,34 @@
+<html><body><pre>
+&lt;%@page contentType="text/html; charset=UTF-8" %>
+&lt;% if (session.getAttribute("nickname") == null) {
+    response.sendRedirect("login.jsp");
+    return;
+}
+%>
+&lt;!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;head>
+   &lt;title>JSP Chat&lt;/title>
+&lt;/head>
+&lt;frameset rows="1*,4*">
+  &lt;frame name="post" src="post.jsp" scrolling="no" title="Post message">
+  &lt;frame name="chat" src="chat" scrolling="yes" title="Chat">
+&lt;/frameset>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/chat/login.jsp b/tomcat-uid/webapps/examples/jsp/chat/login.jsp
new file mode 100644
index 0000000..e1c6496
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/chat/login.jsp
@@ -0,0 +1,33 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<%@page contentType="text/html; charset=UTF-8" %>
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+   <title>JSP Chat</title>
+</head>
+
+<body bgcolor="#FFFFFF">
+
+<form method="POST" action='chat' target="_top" name="loginForm">
+<input type="hidden" name="action" value="login">
+Nickname: <input type="text" name="nickname">
+<input type="submit">
+</form>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/chat/login.jsp.html b/tomcat-uid/webapps/examples/jsp/chat/login.jsp.html
new file mode 100644
index 0000000..d0fbe40
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/chat/login.jsp.html
@@ -0,0 +1,35 @@
+<html><body><pre>
+&lt;!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+&lt;%@page contentType="text/html; charset=UTF-8" %>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;head>
+   &lt;title>JSP Chat&lt;/title>
+&lt;/head>
+
+&lt;body bgcolor="#FFFFFF">
+
+&lt;form method="POST" action='chat' target="_top" name="loginForm">
+&lt;input type="hidden" name="action" value="login">
+Nickname: &lt;input type="text" name="nickname">
+&lt;input type="submit">
+&lt;/form>
+
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/chat/post.jsp b/tomcat-uid/webapps/examples/jsp/chat/post.jsp
new file mode 100644
index 0000000..cc8134d
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/chat/post.jsp
@@ -0,0 +1,55 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<%@page contentType="text/html; charset=UTF-8" %>
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+   <title>JSP Chat</title>
+</head>
+
+<body bgcolor="#FFFFFF">
+
+<form method="POST" action='chat' name="postForm">
+<input type="hidden" name="action" value="post">
+Message: <input type="text" name="message">
+<input type="submit">
+</form>
+
+<br>
+<%
+  String serverName = request.getServerName();
+  if ("localhost".equals(serverName)) {
+      serverName = "127.0.0.1";
+  } else if ("127.0.0.1".equals(serverName)) {
+      serverName = "localhost";
+  }
+
+  String chatUrl = request.getScheme() + "://" + serverName + ":"
+    + request.getServerPort() + request.getContextPath()
+    + request.getServletPath();
+
+  // strip "post.jsp" from the address
+  chatUrl = chatUrl.substring(0, chatUrl.lastIndexOf("/") + 1);
+%>
+<a target="_blank" href="<%=chatUrl %>">Click to open a new chat window</a>
+<em>Note</em>: To avoid hitting the limit on the count of simultaneous
+connections to the same host, imposed by the
+<a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html#sec8.1.4">HTTP specification</a>,
+the second chat window should be opened using a different URL, e.g. with
+an IP address instead of the host name.
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/chat/post.jsp.html b/tomcat-uid/webapps/examples/jsp/chat/post.jsp.html
new file mode 100644
index 0000000..90fa323
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/chat/post.jsp.html
@@ -0,0 +1,57 @@
+<html><body><pre>
+&lt;!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+&lt;%@page contentType="text/html; charset=UTF-8" %>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;head>
+   &lt;title>JSP Chat&lt;/title>
+&lt;/head>
+
+&lt;body bgcolor="#FFFFFF">
+
+&lt;form method="POST" action='chat' name="postForm">
+&lt;input type="hidden" name="action" value="post">
+Message: &lt;input type="text" name="message">
+&lt;input type="submit">
+&lt;/form>
+
+&lt;br>
+&lt;%
+  String serverName = request.getServerName();
+  if ("localhost".equals(serverName)) {
+      serverName = "127.0.0.1";
+  } else if ("127.0.0.1".equals(serverName)) {
+      serverName = "localhost";
+  }
+
+  String chatUrl = request.getScheme() + "://" + serverName + ":"
+    + request.getServerPort() + request.getContextPath()
+    + request.getServletPath();
+
+  // strip "post.jsp" from the address
+  chatUrl = chatUrl.substring(0, chatUrl.lastIndexOf("/") + 1);
+%>
+&lt;a target="_blank" href="&lt;%=chatUrl %>">Click to open a new chat window&lt;/a>
+&lt;em>Note&lt;/em>: To avoid hitting the limit on the count of simultaneous
+connections to the same host, imposed by the
+&lt;a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html#sec8.1.4">HTTP specification&lt;/a>,
+the second chat window should be opened using a different URL, e.g. with
+an IP address instead of the host name.
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/checkbox/CheckTest.html b/tomcat-uid/webapps/examples/jsp/checkbox/CheckTest.html
new file mode 100644
index 0000000..e950ff4
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/checkbox/CheckTest.html
@@ -0,0 +1,56 @@
+<HTML>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<HEAD>
+<title>
+checkbox.CheckTest Bean Properties
+</title>
+<BODY BGCOLOR="white">
+<H2>
+checkbox.CheckTest Bean Properties
+</H2>
+<HR>
+<DL>
+<DT>public class <B>CheckTest</B><DT>extends Object</DL>
+
+<P>
+<HR>
+
+<P>
+
+<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0">
+<TR BGCOLOR="#EEEEFF">
+<TD COLSPAN=3><FONT SIZE="+2">
+<B>Properties Summary</B></FONT></TD>
+</TR>
+<TR BGCOLOR="white">
+<td align="right" valign="top" width="1%">
+<FONT SIZE="-1">
+String
+</FONT></TD>
+<TD><B>CheckTest:fruit</B>
+<BR>
+       </TD>
+<td width="1%">
+<FONT SIZE="-1">
+Multi
+</FONT></TD>
+</TABLE>
+<HR>
+</BODY>
+</HTML>
diff --git a/tomcat-uid/webapps/examples/jsp/checkbox/check.html b/tomcat-uid/webapps/examples/jsp/checkbox/check.html
new file mode 100644
index 0000000..148fe40
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/checkbox/check.html
@@ -0,0 +1,38 @@
+<HTML>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<BODY bgcolor="white">
+
+
+<FORM TYPE=POST ACTION=checkresult.jsp>
+<BR>
+<font size=5 color="red">
+Check all Favorite fruits: <br>
+
+<input TYPE=checkbox name=fruit VALUE=apples> Apples <BR>
+<input TYPE=checkbox name=fruit VALUE=grapes> Grapes <BR>
+<input TYPE=checkbox name=fruit VALUE=oranges> Oranges <BR>
+<input TYPE=checkbox name=fruit VALUE=melons> Melons <BR>
+
+
+<br> <INPUT TYPE=submit name=submit Value="Submit">
+
+</font>
+</FORM>
+</BODY>
+</HTML>
diff --git a/tomcat-uid/webapps/examples/jsp/checkbox/checkresult.jsp b/tomcat-uid/webapps/examples/jsp/checkbox/checkresult.jsp
new file mode 100644
index 0000000..db87ca1
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/checkbox/checkresult.jsp
@@ -0,0 +1,64 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<body bgcolor="white">
+<font size=5 color="red">
+<%! String[] fruits; %>
+<jsp:useBean id="foo" scope="page" class="checkbox.CheckTest" />
+
+<jsp:setProperty name="foo" property="fruit" param="fruit" />
+<hr>
+The checked fruits (got using request) are: <br>
+<% 
+	fruits = request.getParameterValues("fruit");
+%>
+<ul>
+<%
+    if (fruits != null) {
+	  for (int i = 0; i < fruits.length; i++) {
+%>
+<li>
+<%
+	      out.println (util.HTMLFilter.filter(fruits[i]));
+	  }
+	} else out.println ("none selected");
+%>
+</ul>
+<br>
+<hr>
+
+The checked fruits (got using beans) are <br>
+
+<% 
+		fruits = foo.getFruit();
+%>
+<ul>
+<%
+    if (!fruits[0].equals("1")) {
+	  for (int i = 0; i < fruits.length; i++) {
+%>
+<li>
+<%
+		  out.println (util.HTMLFilter.filter(fruits[i]));
+	  }
+	} else out.println ("none selected");
+%>
+</ul>
+</font>
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/checkbox/checkresult.jsp.html b/tomcat-uid/webapps/examples/jsp/checkbox/checkresult.jsp.html
new file mode 100644
index 0000000..d5442d1
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/checkbox/checkresult.jsp.html
@@ -0,0 +1,66 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;body bgcolor="white">
+&lt;font size=5 color="red">
+&lt;%! String[] fruits; %>
+&lt;jsp:useBean id="foo" scope="page" class="checkbox.CheckTest" />
+
+&lt;jsp:setProperty name="foo" property="fruit" param="fruit" />
+&lt;hr>
+The checked fruits (got using request) are: &lt;br>
+&lt;% 
+	fruits = request.getParameterValues("fruit");
+%>
+&lt;ul>
+&lt;%
+    if (fruits != null) {
+	  for (int i = 0; i &lt; fruits.length; i++) {
+%>
+&lt;li>
+&lt;%
+	      out.println (util.HTMLFilter.filter(fruits[i]));
+	  }
+	} else out.println ("none selected");
+%>
+&lt;/ul>
+&lt;br>
+&lt;hr>
+
+The checked fruits (got using beans) are &lt;br>
+
+&lt;% 
+		fruits = foo.getFruit();
+%>
+&lt;ul>
+&lt;%
+    if (!fruits[0].equals("1")) {
+	  for (int i = 0; i &lt; fruits.length; i++) {
+%>
+&lt;li>
+&lt;%
+		  out.println (util.HTMLFilter.filter(fruits[i]));
+	  }
+	} else out.println ("none selected");
+%>
+&lt;/ul>
+&lt;/font>
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/checkbox/cresult.html b/tomcat-uid/webapps/examples/jsp/checkbox/cresult.html
new file mode 100644
index 0000000..c7eabce
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/checkbox/cresult.html
@@ -0,0 +1,34 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="check.html"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="checkresult.jsp.html">Source Code for Checkbox Example<font color="#0000FF"></a>
+  </font> </h3>
+
+<h3><a href="CheckTest.html">Property Sheet for CheckTest
+<font color="#0000FF"></a> </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/colors/ColorGameBean.html b/tomcat-uid/webapps/examples/jsp/colors/ColorGameBean.html
new file mode 100644
index 0000000..dcfc5c8
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/colors/ColorGameBean.html
@@ -0,0 +1,116 @@
+<HTML>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<HEAD>
+<title>
+colors.ColorGameBean Bean Properties
+</title>
+<BODY BGCOLOR="white">
+<H2>
+colors.ColorGameBean Bean Properties
+</H2>
+<HR>
+<DL>
+<DT>public class <B>ColorGameBean</B><DT>extends Object</DL>
+
+<P>
+<HR>
+
+<P>
+
+<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0">
+<TR BGCOLOR="#EEEEFF">
+<TD COLSPAN=3><FONT SIZE="+2">
+<B>Properties Summary</B></FONT></TD>
+</TR>
+<TR BGCOLOR="white">
+<td align="right" valign="top" width="1%">
+<FONT SIZE="-1">
+String
+</FONT></TD>
+<TD><B>ColorGameBean:color2</B>
+<BR>
+       </TD>
+<td width="1%">
+<FONT SIZE="-1">
+Single
+</FONT></TD>
+<TR BGCOLOR="white">
+<td align="right" valign="top" width="1%">
+<FONT SIZE="-1">
+String
+</FONT></TD>
+<TD><B>ColorGameBean:color1</B>
+<BR>
+       </TD>
+<td width="1%">
+<FONT SIZE="-1">
+Single
+</FONT></TD>
+<TR BGCOLOR="white">
+<td align="right" valign="top" width="1%">
+<FONT SIZE="-1">
+int
+</FONT></TD>
+<TD><B>ColorGameBean:attempts</B>
+<BR>
+       </TD>
+<td width="1%">
+<FONT SIZE="-1">
+Single
+</FONT></TD>
+<TR BGCOLOR="white">
+<td align="right" valign="top" width="1%">
+<FONT SIZE="-1">
+boolean
+</FONT></TD>
+<TD><B>ColorGameBean:hint</B>
+<BR>
+       </TD>
+<td width="1%">
+<FONT SIZE="-1">
+Single
+</FONT></TD>
+<TR BGCOLOR="white">
+<td align="right" valign="top" width="1%">
+<FONT SIZE="-1">
+boolean
+</FONT></TD>
+<TD><B>ColorGameBean:success</B>
+<BR>
+       </TD>
+<td width="1%">
+<FONT SIZE="-1">
+Single
+</FONT></TD>
+<TR BGCOLOR="white">
+<td align="right" valign="top" width="1%">
+<FONT SIZE="-1">
+boolean
+</FONT></TD>
+<TD><B>ColorGameBean:hintTaken</B>
+<BR>
+       </TD>
+<td width="1%">
+<FONT SIZE="-1">
+Single
+</FONT></TD>
+</TABLE>
+<HR>
+</BODY>
+</HTML>
diff --git a/tomcat-uid/webapps/examples/jsp/colors/clr.html b/tomcat-uid/webapps/examples/jsp/colors/clr.html
new file mode 100644
index 0000000..58107bc
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/colors/clr.html
@@ -0,0 +1,34 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="colors.html"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="colrs.jsp.html">Source Code for Color Example<font color="#0000FF"></a>
+  </font> </h3>
+
+<h3><a href="ColorGameBean.html">Property Sheet for ColorGameBean
+<font color="#0000FF"></a> </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/colors/colors.html b/tomcat-uid/webapps/examples/jsp/colors/colors.html
new file mode 100644
index 0000000..086738d
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/colors/colors.html
@@ -0,0 +1,47 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<body bgcolor= white>
+<font size=6 color=red>
+
+<hr>
+This web page is an example using JSP and BEANs. 
+<p>
+Guess my favorite two colors 
+
+<p> If you fail to guess both of them - you get yellow on red.
+
+<p> If you guess one of them right, either your foreground or 
+    your background will change to the color that was guessed right.
+
+<p> Guess them both right and your browser foreground/background 
+    will change to my two favorite colors to display this page.
+
+<hr>
+<form method=GET action=colrs.jsp>
+Color #1: <input type=text name= color1 size=16>
+<br>
+Color #2: <input type=text name= color2 size=16>
+<p>
+<input type=submit name=action value="Submit">
+<input type=submit name=action value="Hint">
+</form>
+
+</font>
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/colors/colrs.jsp b/tomcat-uid/webapps/examples/jsp/colors/colrs.jsp
new file mode 100644
index 0000000..e433bbd
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/colors/colrs.jsp
@@ -0,0 +1,70 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<jsp:useBean id="cb" scope="session" class="colors.ColorGameBean" />
+<jsp:setProperty name="cb" property="*" />
+
+<%
+	cb.processRequest(request);
+%>
+
+<body bgcolor=<%= cb.getColor1() %>>
+<font size=6 color=<%= cb.getColor2() %>>
+<p>
+
+<% if (cb.getHint()==true) { %>
+	
+	<p> Hint #1: Vampires prey at night!
+	<p>  <p> Hint #2: Nancy without the n.
+
+<% } %>
+
+<% if  (cb.getSuccess()==true) { %>
+
+    <p> CONGRATULATIONS!!
+	<% if  (cb.getHintTaken()==true) { %>
+    
+        <p> ( although I know you cheated and peeked into the hints)
+
+	<% } %>
+
+<% } %>
+
+<p> Total attempts so far: <%= cb.getAttempts() %>
+<p>
+
+<p>
+
+<form method=POST action=colrs.jsp>
+
+Color #1: <input type=text name= color1 size=16>
+
+<br>
+
+Color #2: <input type=text name= color2 size=16>
+
+<p>
+
+<input type=submit name=action value="Submit">
+<input type=submit name=action value="Hint">
+
+</form>
+
+</font>
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/colors/colrs.jsp.html b/tomcat-uid/webapps/examples/jsp/colors/colrs.jsp.html
new file mode 100644
index 0000000..41af88b
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/colors/colrs.jsp.html
@@ -0,0 +1,72 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;jsp:useBean id="cb" scope="session" class="colors.ColorGameBean" />
+&lt;jsp:setProperty name="cb" property="*" />
+
+&lt;%
+	cb.processRequest(request);
+%>
+
+&lt;body bgcolor=&lt;%= cb.getColor1() %>>
+&lt;font size=6 color=&lt;%= cb.getColor2() %>>
+&lt;p>
+
+&lt;% if (cb.getHint()==true) { %>
+	
+	&lt;p> Hint #1: Vampires prey at night!
+	&lt;p>  &lt;p> Hint #2: Nancy without the n.
+
+&lt;% } %>
+
+&lt;% if  (cb.getSuccess()==true) { %>
+
+    &lt;p> CONGRATULATIONS!!
+	&lt;% if  (cb.getHintTaken()==true) { %>
+    
+        &lt;p> ( although I know you cheated and peeked into the hints)
+
+	&lt;% } %>
+
+&lt;% } %>
+
+&lt;p> Total attempts so far: &lt;%= cb.getAttempts() %>
+&lt;p>
+
+&lt;p>
+
+&lt;form method=POST action=colrs.jsp>
+
+Color #1: &lt;input type=text name= color1 size=16>
+
+&lt;br>
+
+Color #2: &lt;input type=text name= color2 size=16>
+
+&lt;p>
+
+&lt;input type=submit name=action value="Submit">
+&lt;input type=submit name=action value="Hint">
+
+&lt;/form>
+
+&lt;/font>
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/dates/date.html b/tomcat-uid/webapps/examples/jsp/dates/date.html
new file mode 100644
index 0000000..b779181
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/dates/date.html
@@ -0,0 +1,31 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="date.jsp"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="date.jsp.html">Source Code for Date Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/dates/date.jsp b/tomcat-uid/webapps/examples/jsp/dates/date.jsp
new file mode 100644
index 0000000..9c40d78
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/dates/date.jsp
@@ -0,0 +1,41 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<%@ page session="false"%>
+
+<body bgcolor="white">
+<jsp:useBean id='clock' scope='page' class='dates.JspCalendar' type="dates.JspCalendar" />
+
+<font size=4>
+<ul>
+<li>	Day of month: is  <jsp:getProperty name="clock" property="dayOfMonth"/>
+<li>	Year: is  <jsp:getProperty name="clock" property="year"/>
+<li>	Month: is  <jsp:getProperty name="clock" property="month"/>
+<li>	Time: is  <jsp:getProperty name="clock" property="time"/>
+<li>	Date: is  <jsp:getProperty name="clock" property="date"/>
+<li>	Day: is  <jsp:getProperty name="clock" property="day"/>
+<li>	Day Of Year: is  <jsp:getProperty name="clock" property="dayOfYear"/>
+<li>	Week Of Year: is  <jsp:getProperty name="clock" property="weekOfYear"/>
+<li>	era: is  <jsp:getProperty name="clock" property="era"/>
+<li>	DST Offset: is  <jsp:getProperty name="clock" property="DSTOffset"/>
+<li>	Zone Offset: is  <jsp:getProperty name="clock" property="zoneOffset"/>
+</ul>
+</font>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/dates/date.jsp.html b/tomcat-uid/webapps/examples/jsp/dates/date.jsp.html
new file mode 100644
index 0000000..4a8f1e9
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/dates/date.jsp.html
@@ -0,0 +1,43 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;%@ page session="false"%>
+
+&lt;body bgcolor="white">
+&lt;jsp:useBean id='clock' scope='page' class='dates.JspCalendar' type="dates.JspCalendar" />
+
+&lt;font size=4>
+&lt;ul>
+&lt;li>	Day of month: is  &lt;jsp:getProperty name="clock" property="dayOfMonth"/>
+&lt;li>	Year: is  &lt;jsp:getProperty name="clock" property="year"/>
+&lt;li>	Month: is  &lt;jsp:getProperty name="clock" property="month"/>
+&lt;li>	Time: is  &lt;jsp:getProperty name="clock" property="time"/>
+&lt;li>	Date: is  &lt;jsp:getProperty name="clock" property="date"/>
+&lt;li>	Day: is  &lt;jsp:getProperty name="clock" property="day"/>
+&lt;li>	Day Of Year: is  &lt;jsp:getProperty name="clock" property="dayOfYear"/>
+&lt;li>	Week Of Year: is  &lt;jsp:getProperty name="clock" property="weekOfYear"/>
+&lt;li>	era: is  &lt;jsp:getProperty name="clock" property="era"/>
+&lt;li>	DST Offset: is  &lt;jsp:getProperty name="clock" property="DSTOffset"/>
+&lt;li>	Zone Offset: is  &lt;jsp:getProperty name="clock" property="zoneOffset"/>
+&lt;/ul>
+&lt;/font>
+
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/error/er.html b/tomcat-uid/webapps/examples/jsp/error/er.html
new file mode 100644
index 0000000..523f7e3
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/error/er.html
@@ -0,0 +1,31 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="error.html"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="err.jsp.html">Source Code for Error Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/error/err.jsp b/tomcat-uid/webapps/examples/jsp/error/err.jsp
new file mode 100644
index 0000000..08030b0
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/error/err.jsp
@@ -0,0 +1,44 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<body bgcolor="lightblue">
+
+	<%@ page errorPage="errorpge.jsp" %>
+	<jsp:useBean id="foo" scope="request" class="error.Smart" />
+	<% 
+		String name = null;
+
+		if (request.getParameter("name") == null) {
+	%>
+	<%@ include file="error.html" %>
+	<%
+		} else {
+		  foo.setName(request.getParameter("name"));
+		  if (foo.getName().equalsIgnoreCase("integra"))
+		  	name = "acura";
+		  if (name.equalsIgnoreCase("acura")) {
+	%>
+
+	<H1> Yes!!! <a href="http://www.acura.com">Acura</a> is my favorite car.
+
+	<% 
+		  }
+		}	
+	%>	
+</body>
+</html>
+
diff --git a/tomcat-uid/webapps/examples/jsp/error/err.jsp.html b/tomcat-uid/webapps/examples/jsp/error/err.jsp.html
new file mode 100644
index 0000000..65b5654
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/error/err.jsp.html
@@ -0,0 +1,46 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;body bgcolor="lightblue">
+
+	&lt;%@ page errorPage="errorpge.jsp" %>
+	&lt;jsp:useBean id="foo" scope="request" class="error.Smart" />
+	&lt;% 
+		String name = null;
+
+		if (request.getParameter("name") == null) {
+	%>
+	&lt;%@ include file="error.html" %>
+	&lt;%
+		} else {
+		  foo.setName(request.getParameter("name"));
+		  if (foo.getName().equalsIgnoreCase("integra"))
+		  	name = "acura";
+		  if (name.equalsIgnoreCase("acura")) {
+	%>
+
+	&lt;H1> Yes!!! &lt;a href="http://www.acura.com">Acura&lt;/a> is my favorite car.
+
+	&lt;% 
+		  }
+		}	
+	%>	
+&lt;/body>
+&lt;/html>
+
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/error/error.html b/tomcat-uid/webapps/examples/jsp/error/error.html
new file mode 100644
index 0000000..635346f
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/error/error.html
@@ -0,0 +1,37 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<body bgcolor="white">
+
+<h1> This example uses <b>errorpage</b> directive </h1>
+<br>
+<h3> Select my favourite car.</h3>
+<form method=get action=err.jsp>
+<!-- <br> Make a guess: -->
+<SELECT NAME="name" SIZE=5>
+<OPTION VALUE="integra"> Acura Integra <BR>
+<OPTION VALUE="bmw328i"> BMW 328I <BR>
+<OPTION VALUE="z3"> BMW Z3 <BR>
+<OPTION VALUE="infiniti"> InfinitiQ3 <BR>
+<OPTION VALUE="audi"> Audi A8 <BR>
+</SELECT>
+<br> <INPUT TYPE=submit name=submit Value="Submit">
+</form>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/error/errorpge.jsp b/tomcat-uid/webapps/examples/jsp/error/errorpge.jsp
new file mode 100644
index 0000000..113c204
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/error/errorpge.jsp
@@ -0,0 +1,25 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<body bgcolor="red">
+
+	<%@ page isErrorPage="true" %>
+	<h1> The exception <%= exception.getMessage() %> tells me you
+	     made a wrong choice. 
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/error/errorpge.jsp.html b/tomcat-uid/webapps/examples/jsp/error/errorpge.jsp.html
new file mode 100644
index 0000000..69bf244
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/error/errorpge.jsp.html
@@ -0,0 +1,27 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;body bgcolor="red">
+
+	&lt;%@ page isErrorPage="true" %>
+	&lt;h1> The exception &lt;%= exception.getMessage() %> tells me you
+	     made a wrong choice. 
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/forward/forward.jsp b/tomcat-uid/webapps/examples/jsp/forward/forward.jsp
new file mode 100644
index 0000000..8e2ceab
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/forward/forward.jsp
@@ -0,0 +1,34 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<% 
+   double freeMem = Runtime.getRuntime().freeMemory();
+   double totlMem = Runtime.getRuntime().totalMemory();
+   double percent = freeMem/totlMem;
+   if (percent < 0.5) { 
+%>
+
+<jsp:forward page="one.jsp"/>
+
+<% } else { %>
+
+<jsp:forward page="two.html"/>
+
+<% } %>
+
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/forward/forward.jsp.html b/tomcat-uid/webapps/examples/jsp/forward/forward.jsp.html
new file mode 100644
index 0000000..9f0a563
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/forward/forward.jsp.html
@@ -0,0 +1,36 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;% 
+   double freeMem = Runtime.getRuntime().freeMemory();
+   double totlMem = Runtime.getRuntime().totalMemory();
+   double percent = freeMem/totlMem;
+   if (percent &lt; 0.5) { 
+%>
+
+&lt;jsp:forward page="one.jsp"/>
+
+&lt;% } else { %>
+
+&lt;jsp:forward page="two.html"/>
+
+&lt;% } %>
+
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/forward/fwd.html b/tomcat-uid/webapps/examples/jsp/forward/fwd.html
new file mode 100644
index 0000000..e4a701e
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/forward/fwd.html
@@ -0,0 +1,30 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="forward.jsp"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="forward.jsp.html">Source Code for Forward Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/forward/one.jsp b/tomcat-uid/webapps/examples/jsp/forward/one.jsp
new file mode 100644
index 0000000..90297b7
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/forward/one.jsp
@@ -0,0 +1,23 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<body bgcolor="white">
+<font color="red">
+
+VM Memory usage < 50%.
+</html>
\ No newline at end of file
diff --git a/tomcat-uid/webapps/examples/jsp/forward/one.jsp.html b/tomcat-uid/webapps/examples/jsp/forward/one.jsp.html
new file mode 100644
index 0000000..7cb77a0
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/forward/one.jsp.html
@@ -0,0 +1,25 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;body bgcolor="white">
+&lt;font color="red">
+
+VM Memory usage &lt; 50%.
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/forward/two.html b/tomcat-uid/webapps/examples/jsp/forward/two.html
new file mode 100644
index 0000000..4bc9402
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/forward/two.html
@@ -0,0 +1,23 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<body bgcolor="white">
+<font color="red">
+
+VM Memory usage > 50%.
+</html>
\ No newline at end of file
diff --git a/tomcat-uid/webapps/examples/jsp/images/code.gif b/tomcat-uid/webapps/examples/jsp/images/code.gif
new file mode 100644
index 0000000..93af2cd
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/images/code.gif
Binary files differ
diff --git a/tomcat-uid/webapps/examples/jsp/images/execute.gif b/tomcat-uid/webapps/examples/jsp/images/execute.gif
new file mode 100644
index 0000000..f64d70f
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/images/execute.gif
Binary files differ
diff --git a/tomcat-uid/webapps/examples/jsp/images/read.gif b/tomcat-uid/webapps/examples/jsp/images/read.gif
new file mode 100644
index 0000000..66cb4e9
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/images/read.gif
Binary files differ
diff --git a/tomcat-uid/webapps/examples/jsp/images/return.gif b/tomcat-uid/webapps/examples/jsp/images/return.gif
new file mode 100644
index 0000000..af4f68f
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/images/return.gif
Binary files differ
diff --git a/tomcat-uid/webapps/examples/jsp/include/foo.html b/tomcat-uid/webapps/examples/jsp/include/foo.html
new file mode 100644
index 0000000..11acc0e
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/include/foo.html
@@ -0,0 +1,17 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+To get the current time in ms
diff --git a/tomcat-uid/webapps/examples/jsp/include/foo.jsp b/tomcat-uid/webapps/examples/jsp/include/foo.jsp
new file mode 100644
index 0000000..ce4101b
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/include/foo.jsp
@@ -0,0 +1,21 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<body bgcolor="white">
+<font color="red">
+
+<%= System.currentTimeMillis() %>
diff --git a/tomcat-uid/webapps/examples/jsp/include/foo.jsp.html b/tomcat-uid/webapps/examples/jsp/include/foo.jsp.html
new file mode 100644
index 0000000..638d41d
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/include/foo.jsp.html
@@ -0,0 +1,23 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;body bgcolor="white">
+&lt;font color="red">
+
+&lt;%= System.currentTimeMillis() %>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/include/inc.html b/tomcat-uid/webapps/examples/jsp/include/inc.html
new file mode 100644
index 0000000..d2971bb
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/include/inc.html
@@ -0,0 +1,30 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="include.jsp"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="include.jsp.html">Source Code for Include Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/include/include.jsp b/tomcat-uid/webapps/examples/jsp/include/include.jsp
new file mode 100644
index 0000000..34fd6c3
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/include/include.jsp
@@ -0,0 +1,35 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<body bgcolor="white">
+
+<font color="red">
+
+<%@ page buffer="5kb" autoFlush="false" %>
+
+<p>In place evaluation of another JSP which gives you the current time:
+
+<%@ include file="foo.jsp" %>
+
+<p> <jsp:include page="foo.html" flush="true"/> by including the output of another JSP:
+
+<jsp:include page="foo.jsp" flush="true"/>
+
+:-) 
+
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/include/include.jsp.html b/tomcat-uid/webapps/examples/jsp/include/include.jsp.html
new file mode 100644
index 0000000..f45c300
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/include/include.jsp.html
@@ -0,0 +1,37 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;body bgcolor="white">
+
+&lt;font color="red">
+
+&lt;%@ page buffer="5kb" autoFlush="false" %>
+
+&lt;p>In place evaluation of another JSP which gives you the current time:
+
+&lt;%@ include file="foo.jsp" %>
+
+&lt;p> &lt;jsp:include page="foo.html" flush="true"/> by including the output of another JSP:
+
+&lt;jsp:include page="foo.jsp" flush="true"/>
+
+:-) 
+
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/index.html b/tomcat-uid/webapps/examples/jsp/index.html
new file mode 100644
index 0000000..c41acf2
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/index.html
@@ -0,0 +1,370 @@
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+   <meta name="GENERATOR" content="Mozilla/4.61 [en] (WinNT; I) [Netscape]">
+   <meta name="Author" content="Anil K. Vijendran">
+   <title>JSP Examples</title>
+</head>
+<body bgcolor="#FFFFFF">
+<b><font face="Arial, Helvetica, sans-serif"><font size=+2>JSP
+Samples</font></font></b>
+<p>This is a collection of samples demonstrating the usage of different
+parts of the Java Server Pages (JSP) specification.  Both JSP 2.0 and
+JSP 1.2 examples are presented below.
+<p>These examples will only work when these pages are being served by a
+servlet engine; of course, we recommend
+<a href="http://tomcat.apache.org/">Tomcat</a>.
+They will not work if you are viewing these pages via a
+"file://..." URL.
+<p>To navigate your way through the examples, the following icons will
+help:
+<br>&nbsp;
+<table BORDER=0 CELLSPACING=5 WIDTH="85%" >
+<tr VALIGN=TOP>
+<td WIDTH="30"><img SRC="images/execute.gif" ></td>
+
+<td>Execute the example</td>
+</tr>
+
+<tr VALIGN=TOP>
+<td WIDTH="30"><img SRC="images/code.gif" height=24 width=24></td>
+
+<td>Look at the source code for the example</td>
+</tr>
+
+<!--<tr VALIGN=TOP>
+<td WIDTH="30"><img SRC="images/read.gif" height=24 width=24></td>
+
+<td>Read more about this feature</td>
+-->
+
+</tr>
+<tr VALIGN=TOP>
+<td WIDTH="30"><img SRC="images/return.gif" height=24 width=24></td>
+
+<td>Return to this screen</td>
+</tr>
+</table>
+
+<p>Tip: For session scoped beans to work, the cookies must be enabled.
+This can be done using browser options.
+<br>&nbsp;
+<br>
+<b><u><font size="+1">JSP 2.0 Examples</font></u></b><br>
+
+<table BORDER=0 CELLSPACING=5 WIDTH="85%" >
+<tr valign=TOP>
+<td><b>Expression Language</b></td>
+</tr>
+
+<tr valign=TOP>
+<td>Basic Arithmetic</td>
+<td valign=TOP width="30%"><a href="jsp2/el/basic-arithmetic.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/el/basic-arithmetic.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/el/basic-arithmetic.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/el/basic-arithmetic.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>Basic Comparisons</td>
+<td valign=TOP width="30%"><a href="jsp2/el/basic-comparisons.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/el/basic-comparisons.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/el/basic-comparisons.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/el/basic-comparisons.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>Implicit Objects</td>
+<td valign=TOP width="30%"><a href="jsp2/el/implicit-objects.jsp?foo=bar"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/el/implicit-objects.jsp?foo=bar">Execute</a></td>
+
+<td width="30%"><a href="jsp2/el/implicit-objects.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/el/implicit-objects.html">Source</a></td>
+</tr>
+<tr valign=TOP>
+
+<td>Functions</td>
+<td valign=TOP width="30%"><a href="jsp2/el/functions.jsp?foo=JSP+2.0"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/el/functions.jsp?foo=JSP+2.0">Execute</a></td>
+
+<td width="30%"><a href="jsp2/el/functions.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/el/functions.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td><br><b>SimpleTag Handlers and JSP Fragments</b></td>
+</tr>
+
+<tr valign=TOP>
+<td>Hello World Tag</td>
+<td valign=TOP width="30%"><a href="jsp2/simpletag/hello.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/simpletag/hello.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/simpletag/hello.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/simpletag/hello.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>Repeat Tag</td>
+<td valign=TOP width="30%"><a href="jsp2/simpletag/repeat.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/simpletag/repeat.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/simpletag/repeat.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/simpletag/repeat.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>Book Example</td>
+<td valign=TOP width="30%"><a href="jsp2/simpletag/book.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/simpletag/book.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/simpletag/book.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/simpletag/book.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td><br><b>Tag Files</b></td>
+</tr>
+
+<tr valign=TOP>
+<td>Hello World Tag File</td>
+<td valign=TOP width="30%"><a href="jsp2/tagfiles/hello.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/tagfiles/hello.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/tagfiles/hello.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/tagfiles/hello.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>Panel Tag File</td>
+<td valign=TOP width="30%"><a href="jsp2/tagfiles/panel.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/tagfiles/panel.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/tagfiles/panel.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/tagfiles/panel.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>Display Products Example</td>
+<td valign=TOP width="30%"><a href="jsp2/tagfiles/products.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/tagfiles/products.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/tagfiles/products.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/tagfiles/products.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td><br><b>New JSP XML Syntax (.jspx)</b></td>
+</tr>
+
+<tr valign=TOP>
+<td>XHTML Basic Example</td>
+<td valign=TOP width="30%"><a href="jsp2/jspx/basic.jspx"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/jspx/basic.jspx">Execute</a></td>
+
+<td width="30%"><a href="jsp2/jspx/basic.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/jspx/basic.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>SVG (Scalable Vector Graphics)</td>
+<td valign=TOP width="30%"><a href="jsp2/jspx/svgexample.html"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/jspx/svgexample.html">Execute</a></td>
+
+<td width="30%"><a href="jsp2/jspx/textRotate.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/jspx/textRotate.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td><br><b>Other JSP 2.0 Features</b></td>
+</tr>
+
+<tr valign=TOP>
+<td>&lt;jsp:attribute&gt; and &lt;jsp:body&gt;</td>
+<td valign=TOP width="30%"><a href="jsp2/jspattribute/jspattribute.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/jspattribute/jspattribute.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/jspattribute/jspattribute.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/jspattribute/jspattribute.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>Shuffle Example</td>
+<td valign=TOP width="30%"><a href="jsp2/jspattribute/shuffle.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/jspattribute/shuffle.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/jspattribute/shuffle.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/jspattribute/shuffle.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>Attributes With Dynamic Names</td>
+<td valign=TOP width="30%"><a href="jsp2/misc/dynamicattrs.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/misc/dynamicattrs.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/misc/dynamicattrs.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/misc/dynamicattrs.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>JSP Configuration</td>
+<td valign=TOP width="30%"><a href="jsp2/misc/config.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="jsp2/misc/config.jsp">Execute</a></td>
+
+<td width="30%"><a href="jsp2/misc/config.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsp2/misc/config.html">Source</a></td>
+</tr>
+
+</table>
+
+<br>
+<b><u><font size="+1">JSP 1.2 Examples</font></u></b><br>
+<table BORDER=0 CELLSPACING=5 WIDTH="85%" >
+<tr VALIGN=TOP>
+<td>Numberguess&nbsp;</td>
+
+<td VALIGN=TOP WIDTH="30%"><a href="num/numguess.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="num/numguess.jsp">Execute</a></td>
+
+<td WIDTH="30%"><a href="num/numguess.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="num/numguess.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>Date&nbsp;</td>
+
+<td VALIGN=TOP WIDTH="30%"><a href="dates/date.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="dates/date.jsp">Execute</a></td>
+
+<td WIDTH="30%"><a href="dates/date.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="dates/date.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>Snoop</td>
+
+<td WIDTH="30%"><a href="snp/snoop.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="snp/snoop.jsp">Execute</a></td>
+
+<td WIDTH="30%"><a href="snp/snoop.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="snp/snoop.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>ErrorPage&nbsp;</td>
+
+<td WIDTH="30%"><a href="error/error.html"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="error/error.html">Execute</a></td>
+
+<td WIDTH="30%"><a href="error/er.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="error/er.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>Carts&nbsp;</td>
+
+<td VALIGN=TOP WIDTH="30%"><a href="sessions/carts.html"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="sessions/carts.html">Execute</a></td>
+
+<td WIDTH="30%"><a href="sessions/crt.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="sessions/crt.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>Checkbox&nbsp;</td>
+
+<td VALIGN=TOP WIDTH="30%"><a href="checkbox/check.html"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="checkbox/check.html">Execute</a></td>
+
+<td WIDTH="30%"><a href="checkbox/cresult.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="checkbox/cresult.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>Color&nbsp;</td>
+
+<td VALIGN=TOP WIDTH="30%"><a href="colors/colors.html"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="colors/colors.html">Execute</a></td>
+
+<td WIDTH="30%"><a href="colors/clr.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="colors/clr.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>Calendar&nbsp;</td>
+
+<td WIDTH="30%"><a href="cal/login.html"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="cal/login.html">Execute</a></td>
+
+<td WIDTH="30%"><a href="cal/calendar.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="cal/calendar.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>Include&nbsp;</td>
+
+<td VALIGN=TOP WIDTH="30%"><a href="include/include.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="include/include.jsp">Execute</a></td>
+
+<td WIDTH="30%"><a href="include/inc.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="include/inc.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>Forward&nbsp;</td>
+
+<td VALIGN=TOP WIDTH="30%"><a href="forward/forward.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="forward/forward.jsp">Execute</a></td>
+
+<td WIDTH="30%"><a href="forward/fwd.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="forward/fwd.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>Plugin&nbsp;</td>
+
+<td VALIGN=TOP WIDTH="30%"><a href="plugin/plugin.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="plugin/plugin.jsp">Execute</a></td>
+
+<td WIDTH="30%"><a href="plugin/plugin.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="plugin/plugin.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>JSP-Servlet-JSP&nbsp;</td>
+
+<td VALIGN=TOP WIDTH="30%"><a href="jsptoserv/jsptoservlet.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="jsptoserv/jsptoservlet.jsp">Execute</a></td>
+
+<td WIDTH="30%"><a href="jsptoserv/jts.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="jsptoserv/jts.html">Source</a></td>
+</tr>
+
+<tr VALIGN=TOP>
+<td>Custom tag example</td>
+
+<td VALIGN=TOP WIDTH="30%"><a href="simpletag/foo.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a><a href="simpletag/foo.jsp">Execute</a></td>
+
+<td WIDTH="30%"><a href="simpletag/foo.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="simpletag/foo.html">Source</a></td>
+</tr>
+
+<tr valign=TOP>
+<td>XML syntax example</td>
+<td valign=TOP width="30%"><a href="xml/xml.jsp"><img src="images/execute.gif" hspace=4 border=0  align=top></a><a href="xml/xml.jsp">Execute</a></td>
+
+<td width="30%"><a href="xml/xml.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a><a href="xml/xml.html">Source</a></td>
+</tr>
+
+</table>
+
+<br/>
+<b><u><font size="+1">Tag Plugins</font></u></b><br>
+<table BORDER=0 CELLSPACING=5 WIDTH="85%" >
+
+<tr VALIGN=TOP>
+  <td>If&nbsp;</td>
+  <td VALIGN=TOP WIDTH="30%">
+    <a href="tagplugin/if.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  
+align=TOP></a>
+    <a href="tagplugin/if.jsp">Execute</a>
+  </td>
+  <td WIDTH="30%">
+    <a href="tagplugin/if.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 hei
+ght=24 width=24 align=TOP></a>
+    <a href="tagplugin/if.html">Source</a>
+  </td>
+</tr>
+
+<tr VALIGN=TOP>
+  <td>ForEach&nbsp;</td>
+  <td VALIGN=TOP WIDTH="30%">
+    <a href="tagplugin/foreach.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  
+align=TOP></a>
+    <a href="tagplugin/foreach.jsp">Execute</a>
+  </td>
+  <td WIDTH="30%">
+    <a href="tagplugin/foreach.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 hei
+ght=24 width=24 align=TOP></a>
+    <a href="tagplugin/foreach.html">Source</a>
+  </td>
+</tr>
+
+<tr VALIGN=TOP>
+  <td>Choose&nbsp;</td>
+  <td VALIGN=TOP WIDTH="30%">
+    <a href="tagplugin/choose.jsp"><img SRC="images/execute.gif" HSPACE=4 BORDER=0  align=TOP></a>
+    <a href="tagplugin/choose.jsp">Execute</a>
+  </td>
+  <td WIDTH="30%">
+    <a href="tagplugin/choose.html"><img SRC="images/code.gif" HSPACE=4 BORDER=0 height=24 width=24 align=TOP></a>
+    <a href="tagplugin/choose.html">Source</a>
+  </td>
+</tr>
+
+</table>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/Functions.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/el/Functions.java.html
new file mode 100644
index 0000000..350fce6
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/Functions.java.html
@@ -0,0 +1,45 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package jsp2.examples.el;
+
+/**
+ * Defines the functions for the jsp2 example tag library.
+ * 
+ * &lt;p>Each function is defined as a static method.&lt;/p>
+ */
+public class Functions {
+    public static String reverse( String text ) {
+        return new StringBuffer( text ).reverse().toString();
+    }
+
+    public static int numVowels( String text ) {
+        String vowels = "aeiouAEIOU";
+	int result = 0;
+        for( int i = 0; i &lt; text.length(); i++ ) {
+	    if( vowels.indexOf( text.charAt( i ) ) != -1 ) {
+	        result++;
+	    }
+	}
+	return result;
+    }
+
+    public static String caps( String text ) {
+        return text.toUpperCase();
+    }
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-arithmetic.html b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-arithmetic.html
new file mode 100644
index 0000000..ca88b7f
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-arithmetic.html
@@ -0,0 +1,30 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="basic-arithmetic.jsp"><img src="../../images/execute.gif" align="right" border="0"></a><a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="basic-arithmetic.jsp.html">Source Code for Basic Arithmetic Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-arithmetic.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-arithmetic.jsp
new file mode 100644
index 0000000..e2ec74c
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-arithmetic.jsp
@@ -0,0 +1,88 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+  <head>
+    <title>JSP 2.0 Expression Language - Basic Arithmetic</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Expression Language - Basic Arithmetic</h1>
+    <hr>
+    This example illustrates basic Expression Language arithmetic.
+    Addition (+), subtraction (-), multiplication (*), division (/ or div), 
+    and modulus (% or mod) are all supported.  Error conditions, like
+    division by zero, are handled gracefully.
+    <br>
+    <blockquote>
+      <code>
+        <table border="1">
+          <thead>
+	    <td><b>EL Expression</b></td>
+	    <td><b>Result</b></td>
+	  </thead>
+	  <tr>
+	    <td>\${1}</td>
+	    <td>${1}</td>
+	  </tr>
+	  <tr>
+	    <td>\${1 + 2}</td>
+	    <td>${1 + 2}</td>
+	  </tr>
+	  <tr>
+	    <td>\${1.2 + 2.3}</td>
+	    <td>${1.2 + 2.3}</td>
+	  </tr>
+	  <tr>
+	    <td>\${1.2E4 + 1.4}</td>
+	    <td>${1.2E4 + 1.4}</td>
+	  </tr>
+	  <tr>
+	    <td>\${-4 - 2}</td>
+	    <td>${-4 - 2}</td>
+	  </tr>
+	  <tr>
+	    <td>\${21 * 2}</td>
+	    <td>${21 * 2}</td>
+	  </tr>
+	  <tr>
+	    <td>\${3/4}</td>
+	    <td>${3/4}</td>
+	  </tr>
+	  <tr>
+	    <td>\${3 div 4}</td>
+	    <td>${3 div 4}</td>
+	  </tr>
+	  <tr>
+	    <td>\${3/0}</td>
+	    <td>${3/0}</td>
+	  </tr>
+	  <tr>
+	    <td>\${10%4}</td>
+	    <td>${10%4}</td>
+	  </tr>
+	  <tr>
+	    <td>\${10 mod 4}</td>
+	    <td>${10 mod 4}</td>
+	  </tr>
+    <tr>
+      <td>\${(1==2) ? 3 : 4}</td>
+      <td>${(1==2) ? 3 : 4}</td>
+    </tr>
+	</table>
+      </code>
+    </blockquote>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-arithmetic.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-arithmetic.jsp.html
new file mode 100644
index 0000000..4aa05c8
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-arithmetic.jsp.html
@@ -0,0 +1,90 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Expression Language - Basic Arithmetic&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Expression Language - Basic Arithmetic&lt;/h1>
+    &lt;hr>
+    This example illustrates basic Expression Language arithmetic.
+    Addition (+), subtraction (-), multiplication (*), division (/ or div), 
+    and modulus (% or mod) are all supported.  Error conditions, like
+    division by zero, are handled gracefully.
+    &lt;br>
+    &lt;blockquote>
+      &lt;code>
+        &lt;table border="1">
+          &lt;thead>
+	    &lt;td>&lt;b>EL Expression&lt;/b>&lt;/td>
+	    &lt;td>&lt;b>Result&lt;/b>&lt;/td>
+	  &lt;/thead>
+	  &lt;tr>
+	    &lt;td>\${1}&lt;/td>
+	    &lt;td>${1}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${1 + 2}&lt;/td>
+	    &lt;td>${1 + 2}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${1.2 + 2.3}&lt;/td>
+	    &lt;td>${1.2 + 2.3}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${1.2E4 + 1.4}&lt;/td>
+	    &lt;td>${1.2E4 + 1.4}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${-4 - 2}&lt;/td>
+	    &lt;td>${-4 - 2}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${21 * 2}&lt;/td>
+	    &lt;td>${21 * 2}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${3/4}&lt;/td>
+	    &lt;td>${3/4}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${3 div 4}&lt;/td>
+	    &lt;td>${3 div 4}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${3/0}&lt;/td>
+	    &lt;td>${3/0}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${10%4}&lt;/td>
+	    &lt;td>${10%4}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${10 mod 4}&lt;/td>
+	    &lt;td>${10 mod 4}&lt;/td>
+	  &lt;/tr>
+    &lt;tr>
+      &lt;td>\${(1==2) ? 3 : 4}&lt;/td>
+      &lt;td>${(1==2) ? 3 : 4}&lt;/td>
+    &lt;/tr>
+	&lt;/table>
+      &lt;/code>
+    &lt;/blockquote>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-comparisons.html b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-comparisons.html
new file mode 100644
index 0000000..0102232
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-comparisons.html
@@ -0,0 +1,30 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="basic-comparisons.jsp"><img src="../../images/execute.gif" align="right" border="0"></a><a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="basic-comparisons.jsp.html">Source Code for Basic Comparisons Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-comparisons.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-comparisons.jsp
new file mode 100644
index 0000000..e01188a
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-comparisons.jsp
@@ -0,0 +1,116 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+  <head>
+    <title>JSP 2.0 Expression Language - Basic Comparisons</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Expression Language - Basic Comparisons</h1>
+    <hr>
+    This example illustrates basic Expression Language comparisons.
+    The following comparison operators are supported:
+    <ul>
+      <li>Less-than (&lt; or lt)</li>
+      <li>Greater-than (&gt; or gt)</li>
+      <li>Less-than-or-equal (&lt;= or le)</li>
+      <li>Greater-than-or-equal (&gt;= or ge)</li>
+      <li>Equal (== or eq)</li>
+      <li>Not Equal (!= or ne)</li>
+    </ul>
+    <blockquote>
+      <u><b>Numeric</b></u>
+      <code>
+        <table border="1">
+          <thead>
+	    <td><b>EL Expression</b></td>
+	    <td><b>Result</b></td>
+	  </thead>
+	  <tr>
+	    <td>\${1 &lt; 2}</td>
+	    <td>${1 < 2}</td>
+	  </tr>
+	  <tr>
+	    <td>\${1 lt 2}</td>
+	    <td>${1 lt 2}</td>
+	  </tr>
+	  <tr>
+	    <td>\${1 &gt; (4/2)}</td>
+	    <td>${1 > (4/2)}</td>
+	  </tr>
+	  <tr>
+	    <td>\${1 gt (4/2)}</td>
+	    <td>${1 gt (4/2)}</td>
+	  </tr>
+	  <tr>
+	    <td>\${4.0 &gt;= 3}</td>
+	    <td>${4.0 >= 3}</td>
+	  </tr>
+	  <tr>
+	    <td>\${4.0 ge 3}</td>
+	    <td>${4.0 ge 3}</td>
+	  </tr>
+	  <tr>
+	    <td>\${4 &lt;= 3}</td>
+	    <td>${4 <= 3}</td>
+	  </tr>
+	  <tr>
+	    <td>\${4 le 3}</td>
+	    <td>${4 le 3}</td>
+	  </tr>
+	  <tr>
+	    <td>\${100.0 == 100}</td>
+	    <td>${100.0 == 100}</td>
+	  </tr>
+	  <tr>
+	    <td>\${100.0 eq 100}</td>
+	    <td>${100.0 eq 100}</td>
+	  </tr>
+	  <tr>
+	    <td>\${(10*10) != 100}</td>
+	    <td>${(10*10) != 100}</td>
+	  </tr>
+	  <tr>
+	    <td>\${(10*10) ne 100}</td>
+	    <td>${(10*10) ne 100}</td>
+	  </tr>
+	</table>
+      </code>
+      <br>
+      <u><b>Alphabetic</b></u>
+      <code>
+        <table border="1">
+          <thead>
+	    <td><b>EL Expression</b></td>
+	    <td><b>Result</b></td>
+	  </thead>
+	  <tr>
+	    <td>\${'a' &lt; 'b'}</td>
+	    <td>${'a' < 'b'}</td>
+	  </tr>
+	  <tr>
+	    <td>\${'hip' &gt; 'hit'}</td>
+	    <td>${'hip' > 'hit'}</td>
+	  </tr>
+	  <tr>
+	    <td>\${'4' &gt; 3}</td>
+	    <td>${'4' > 3}</td>
+	  </tr>
+	</table>
+      </code>
+    </blockquote>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-comparisons.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-comparisons.jsp.html
new file mode 100644
index 0000000..efc4da3
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/basic-comparisons.jsp.html
@@ -0,0 +1,118 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Expression Language - Basic Comparisons&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Expression Language - Basic Comparisons&lt;/h1>
+    &lt;hr>
+    This example illustrates basic Expression Language comparisons.
+    The following comparison operators are supported:
+    &lt;ul>
+      &lt;li>Less-than (&amp;lt; or lt)&lt;/li>
+      &lt;li>Greater-than (&amp;gt; or gt)&lt;/li>
+      &lt;li>Less-than-or-equal (&amp;lt;= or le)&lt;/li>
+      &lt;li>Greater-than-or-equal (&amp;gt;= or ge)&lt;/li>
+      &lt;li>Equal (== or eq)&lt;/li>
+      &lt;li>Not Equal (!= or ne)&lt;/li>
+    &lt;/ul>
+    &lt;blockquote>
+      &lt;u>&lt;b>Numeric&lt;/b>&lt;/u>
+      &lt;code>
+        &lt;table border="1">
+          &lt;thead>
+	    &lt;td>&lt;b>EL Expression&lt;/b>&lt;/td>
+	    &lt;td>&lt;b>Result&lt;/b>&lt;/td>
+	  &lt;/thead>
+	  &lt;tr>
+	    &lt;td>\${1 &amp;lt; 2}&lt;/td>
+	    &lt;td>${1 &lt; 2}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${1 lt 2}&lt;/td>
+	    &lt;td>${1 lt 2}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${1 &amp;gt; (4/2)}&lt;/td>
+	    &lt;td>${1 > (4/2)}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${1 gt (4/2)}&lt;/td>
+	    &lt;td>${1 gt (4/2)}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${4.0 &amp;gt;= 3}&lt;/td>
+	    &lt;td>${4.0 >= 3}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${4.0 ge 3}&lt;/td>
+	    &lt;td>${4.0 ge 3}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${4 &amp;lt;= 3}&lt;/td>
+	    &lt;td>${4 &lt;= 3}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${4 le 3}&lt;/td>
+	    &lt;td>${4 le 3}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${100.0 == 100}&lt;/td>
+	    &lt;td>${100.0 == 100}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${100.0 eq 100}&lt;/td>
+	    &lt;td>${100.0 eq 100}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${(10*10) != 100}&lt;/td>
+	    &lt;td>${(10*10) != 100}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${(10*10) ne 100}&lt;/td>
+	    &lt;td>${(10*10) ne 100}&lt;/td>
+	  &lt;/tr>
+	&lt;/table>
+      &lt;/code>
+      &lt;br>
+      &lt;u>&lt;b>Alphabetic&lt;/b>&lt;/u>
+      &lt;code>
+        &lt;table border="1">
+          &lt;thead>
+	    &lt;td>&lt;b>EL Expression&lt;/b>&lt;/td>
+	    &lt;td>&lt;b>Result&lt;/b>&lt;/td>
+	  &lt;/thead>
+	  &lt;tr>
+	    &lt;td>\${'a' &amp;lt; 'b'}&lt;/td>
+	    &lt;td>${'a' &lt; 'b'}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${'hip' &amp;gt; 'hit'}&lt;/td>
+	    &lt;td>${'hip' > 'hit'}&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${'4' &amp;gt; 3}&lt;/td>
+	    &lt;td>${'4' > 3}&lt;/td>
+	  &lt;/tr>
+	&lt;/table>
+      &lt;/code>
+    &lt;/blockquote>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/functions.html b/tomcat-uid/webapps/examples/jsp/jsp2/el/functions.html
new file mode 100644
index 0000000..0fdb080
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/functions.html
@@ -0,0 +1,32 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="functions.jsp?foo=JSP+2.0"><img src="../../images/execute.gif" align="right" border="0"></a><a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="functions.jsp.html">Source Code for functions.jsp<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="Functions.java.html">Source Code for Functions.java<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/functions.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/el/functions.jsp
new file mode 100644
index 0000000..66478c0
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/functions.jsp
@@ -0,0 +1,66 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
+<%@ taglib prefix="my" uri="http://tomcat.apache.org/jsp2-example-taglib"%>
+
+<html>
+  <head>
+    <title>JSP 2.0 Expression Language - Functions</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Expression Language - Functions</h1>
+    <hr>
+    An upgrade from the JSTL expression language, the JSP 2.0 EL also
+    allows for simple function invocation.  Functions are defined
+    by tag libraries and are implemented by a Java programmer as 
+    static methods.
+
+    <blockquote>
+      <u><b>Change Parameter</b></u>
+      <form action="functions.jsp" method="GET">
+	  foo = <input type="text" name="foo" value="${fn:escapeXml(param["foo"])}">
+          <input type="submit">
+      </form>
+      <br>
+      <code>
+        <table border="1">
+          <thead>
+	    <td><b>EL Expression</b></td>
+	    <td><b>Result</b></td>
+	  </thead>
+	  <tr>
+	    <td>\${param["foo"]}</td>
+	    <td>${fn:escapeXml(param["foo"])}&nbsp;</td>
+	  </tr>
+	  <tr>
+	    <td>\${my:reverse(param["foo"])}</td>
+	    <td>${my:reverse(fn:escapeXml(param["foo"]))}&nbsp;</td>
+	  </tr>
+	  <tr>
+	    <td>\${my:reverse(my:reverse(param["foo"]))}</td>
+	    <td>${my:reverse(my:reverse(fn:escapeXml(param["foo"])))}&nbsp;</td>
+	  </tr>
+	  <tr>
+	    <td>\${my:countVowels(param["foo"])}</td>
+	    <td>${my:countVowels(fn:escapeXml(param["foo"]))}&nbsp;</td>
+	  </tr>
+	</table>
+      </code>
+    </blockquote>
+  </body>
+</html>
+
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/functions.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/el/functions.jsp.html
new file mode 100644
index 0000000..9ac0c79
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/functions.jsp.html
@@ -0,0 +1,68 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
+&lt;%@ taglib prefix="my" uri="http://tomcat.apache.org/jsp2-example-taglib"%>
+
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Expression Language - Functions&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Expression Language - Functions&lt;/h1>
+    &lt;hr>
+    An upgrade from the JSTL expression language, the JSP 2.0 EL also
+    allows for simple function invocation.  Functions are defined
+    by tag libraries and are implemented by a Java programmer as 
+    static methods.
+
+    &lt;blockquote>
+      &lt;u>&lt;b>Change Parameter&lt;/b>&lt;/u>
+      &lt;form action="functions.jsp" method="GET">
+	  foo = &lt;input type="text" name="foo" value="${fn:escapeXml(param["foo"])}">
+          &lt;input type="submit">
+      &lt;/form>
+      &lt;br>
+      &lt;code>
+        &lt;table border="1">
+          &lt;thead>
+	    &lt;td>&lt;b>EL Expression&lt;/b>&lt;/td>
+	    &lt;td>&lt;b>Result&lt;/b>&lt;/td>
+	  &lt;/thead>
+	  &lt;tr>
+	    &lt;td>\${param["foo"]}&lt;/td>
+	    &lt;td>${fn:escapeXml(param["foo"])}&amp;nbsp;&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${my:reverse(param["foo"])}&lt;/td>
+	    &lt;td>${my:reverse(fn:escapeXml(param["foo"]))}&amp;nbsp;&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${my:reverse(my:reverse(param["foo"]))}&lt;/td>
+	    &lt;td>${my:reverse(my:reverse(fn:escapeXml(param["foo"])))}&amp;nbsp;&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${my:countVowels(param["foo"])}&lt;/td>
+	    &lt;td>${my:countVowels(fn:escapeXml(param["foo"]))}&amp;nbsp;&lt;/td>
+	  &lt;/tr>
+	&lt;/table>
+      &lt;/code>
+    &lt;/blockquote>
+  &lt;/body>
+&lt;/html>
+
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/implicit-objects.html b/tomcat-uid/webapps/examples/jsp/jsp2/el/implicit-objects.html
new file mode 100644
index 0000000..2046603
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/implicit-objects.html
@@ -0,0 +1,31 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="implicit-objects.jsp?foo=bar"><img src="../../images/execute.gif" align="right" border="0"></a><a href="../../index.html">
+<img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="implicit-objects.jsp.html">Source Code for Implicit Objects Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/implicit-objects.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/el/implicit-objects.jsp
new file mode 100644
index 0000000..8d6841a
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/implicit-objects.jsp
@@ -0,0 +1,89 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
+
+<html>
+  <head>
+    <title>JSP 2.0 Expression Language - Implicit Objects</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Expression Language - Implicit Objects</h1>
+    <hr>
+    This example illustrates some of the implicit objects available 
+    in the Expression Lanaguage.  The following implicit objects are 
+    available (not all illustrated here):
+    <ul>
+      <li>pageContext - the PageContext object</li>
+      <li>pageScope - a Map that maps page-scoped attribute names to 
+          their values</li>
+      <li>requestScope - a Map that maps request-scoped attribute names 
+          to their values</li>
+      <li>sessionScope - a Map that maps session-scoped attribute names 
+          to their values</li>
+      <li>applicationScope - a Map that maps application-scoped attribute 
+          names to their values</li>
+      <li>param - a Map that maps parameter names to a single String 
+          parameter value</li>
+      <li>paramValues - a Map that maps parameter names to a String[] of 
+          all values for that parameter</li>
+      <li>header - a Map that maps header names to a single String 
+          header value</li>
+      <li>headerValues - a Map that maps header names to a String[] of 
+          all values for that header</li>
+      <li>initParam - a Map that maps context initialization parameter 
+          names to their String parameter value</li>
+      <li>cookie - a Map that maps cookie names to a single Cookie object.</li>
+    </ul>
+
+    <blockquote>
+      <u><b>Change Parameter</b></u>
+      <form action="implicit-objects.jsp" method="GET">
+	  foo = <input type="text" name="foo" value="${fn:escapeXml(param["foo"])}">
+          <input type="submit">
+      </form>
+      <br>
+      <code>
+        <table border="1">
+          <thead>
+	    <td><b>EL Expression</b></td>
+	    <td><b>Result</b></td>
+	  </thead>
+	  <tr>
+	    <td>\${param.foo}</td>
+	    <td>${fn:escapeXml(param["foo"])}&nbsp;</td>
+	  </tr>
+	  <tr>
+	    <td>\${param["foo"]}</td>
+	    <td>${fn:escapeXml(param["foo"])}&nbsp;</td>
+	  </tr>
+	  <tr>
+	    <td>\${header["host"]}</td>
+	    <td>${fn:escapeXml(header["host"])}&nbsp;</td>
+	  </tr>
+	  <tr>
+	    <td>\${header["accept"]}</td>
+	    <td>${fn:escapeXml(header["accept"])}&nbsp;</td>
+	  </tr>
+	  <tr>
+	    <td>\${header["user-agent"]}</td>
+	    <td>${fn:escapeXml(header["user-agent"])}&nbsp;</td>
+	  </tr>
+	</table>
+      </code>
+    </blockquote>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/el/implicit-objects.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/el/implicit-objects.jsp.html
new file mode 100644
index 0000000..a2d9bdc
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/el/implicit-objects.jsp.html
@@ -0,0 +1,91 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
+
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Expression Language - Implicit Objects&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Expression Language - Implicit Objects&lt;/h1>
+    &lt;hr>
+    This example illustrates some of the implicit objects available 
+    in the Expression Lanaguage.  The following implicit objects are 
+    available (not all illustrated here):
+    &lt;ul>
+      &lt;li>pageContext - the PageContext object&lt;/li>
+      &lt;li>pageScope - a Map that maps page-scoped attribute names to 
+          their values&lt;/li>
+      &lt;li>requestScope - a Map that maps request-scoped attribute names 
+          to their values&lt;/li>
+      &lt;li>sessionScope - a Map that maps session-scoped attribute names 
+          to their values&lt;/li>
+      &lt;li>applicationScope - a Map that maps application-scoped attribute 
+          names to their values&lt;/li>
+      &lt;li>param - a Map that maps parameter names to a single String 
+          parameter value&lt;/li>
+      &lt;li>paramValues - a Map that maps parameter names to a String[] of 
+          all values for that parameter&lt;/li>
+      &lt;li>header - a Map that maps header names to a single String 
+          header value&lt;/li>
+      &lt;li>headerValues - a Map that maps header names to a String[] of 
+          all values for that header&lt;/li>
+      &lt;li>initParam - a Map that maps context initialization parameter 
+          names to their String parameter value&lt;/li>
+      &lt;li>cookie - a Map that maps cookie names to a single Cookie object.&lt;/li>
+    &lt;/ul>
+
+    &lt;blockquote>
+      &lt;u>&lt;b>Change Parameter&lt;/b>&lt;/u>
+      &lt;form action="implicit-objects.jsp" method="GET">
+	  foo = &lt;input type="text" name="foo" value="${fn:escapeXml(param["foo"])}">
+          &lt;input type="submit">
+      &lt;/form>
+      &lt;br>
+      &lt;code>
+        &lt;table border="1">
+          &lt;thead>
+	    &lt;td>&lt;b>EL Expression&lt;/b>&lt;/td>
+	    &lt;td>&lt;b>Result&lt;/b>&lt;/td>
+	  &lt;/thead>
+	  &lt;tr>
+	    &lt;td>\${param.foo}&lt;/td>
+	    &lt;td>${fn:escapeXml(param["foo"])}&amp;nbsp;&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${param["foo"]}&lt;/td>
+	    &lt;td>${fn:escapeXml(param["foo"])}&amp;nbsp;&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${header["host"]}&lt;/td>
+	    &lt;td>${fn:escapeXml(header["host"])}&amp;nbsp;&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${header["accept"]}&lt;/td>
+	    &lt;td>${fn:escapeXml(header["accept"])}&amp;nbsp;&lt;/td>
+	  &lt;/tr>
+	  &lt;tr>
+	    &lt;td>\${header["user-agent"]}&lt;/td>
+	    &lt;td>${fn:escapeXml(header["user-agent"])}&amp;nbsp;&lt;/td>
+	  &lt;/tr>
+	&lt;/table>
+      &lt;/code>
+    &lt;/blockquote>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/FooBean.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/FooBean.java.html
new file mode 100644
index 0000000..0b15181
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/FooBean.java.html
@@ -0,0 +1,38 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+package jsp2.examples;
+
+public class FooBean {
+    private String bar;
+    
+    public FooBean() {
+        bar = "Initial value";
+    }
+    
+    public String getBar() {
+        return this.bar;
+    }
+    
+    public void setBar(String bar) {
+        this.bar = bar;
+    }
+    
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/HelloWorldSimpleTag.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/HelloWorldSimpleTag.java.html
new file mode 100644
index 0000000..c409839
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/HelloWorldSimpleTag.java.html
@@ -0,0 +1,34 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+package jsp2.examples.simpletag;
+
+import javax.servlet.jsp.JspException;
+import javax.servlet.jsp.tagext.SimpleTagSupport;
+import java.io.IOException;
+
+/**
+ * SimpleTag handler that prints "Hello, world!"
+ */
+public class HelloWorldSimpleTag extends SimpleTagSupport {
+    public void doTag() throws JspException, IOException {
+	getJspContext().getOut().write( "Hello, world!" );
+    }
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/ShuffleSimpleTag.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/ShuffleSimpleTag.java.html
new file mode 100644
index 0000000..1b66d06
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/ShuffleSimpleTag.java.html
@@ -0,0 +1,83 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+package jsp2.examples.simpletag;
+
+import javax.servlet.jsp.JspException;
+import javax.servlet.jsp.tagext.JspFragment;
+import javax.servlet.jsp.tagext.SimpleTagSupport;
+import java.io.IOException;
+
+/**
+ * SimpleTag handler that accepts takes three attributes of type
+ * JspFragment and invokes then in a random order.
+ */
+public class ShuffleSimpleTag extends SimpleTagSupport {
+    private JspFragment fragment1;
+    private JspFragment fragment2;
+    private JspFragment fragment3;
+
+    public void doTag() throws JspException, IOException {
+        switch( (int)(Math.random() * 6) ) {
+            case 0:
+                fragment1.invoke( null );
+                fragment2.invoke( null );
+                fragment3.invoke( null );
+                break;
+            case 1:
+                fragment1.invoke( null );
+                fragment3.invoke( null );
+                fragment2.invoke( null );
+                break;
+            case 2:
+                fragment2.invoke( null );
+                fragment1.invoke( null );
+                fragment3.invoke( null );
+                break;
+            case 3:
+                fragment2.invoke( null );
+                fragment3.invoke( null );
+                fragment1.invoke( null );
+                break;
+            case 4:
+                fragment3.invoke( null );
+                fragment1.invoke( null );
+                fragment2.invoke( null );
+                break;
+            case 5:
+                fragment3.invoke( null );
+                fragment2.invoke( null );
+                fragment1.invoke( null );
+                break;
+        }
+    }
+
+    public void setFragment1( JspFragment fragment1 ) {
+        this.fragment1 = fragment1;
+    }
+    
+    public void setFragment2( JspFragment fragment2 ) {
+        this.fragment2 = fragment2;
+    }
+    
+    public void setFragment3( JspFragment fragment3 ) {
+        this.fragment3 = fragment3;
+    }
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/TileSimpleTag.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/TileSimpleTag.java.html
new file mode 100644
index 0000000..4453222
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/TileSimpleTag.java.html
@@ -0,0 +1,48 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+package jsp2.examples.simpletag;
+
+import javax.servlet.jsp.JspException;
+import javax.servlet.jsp.tagext.SimpleTagSupport;
+import java.io.IOException;
+
+/**
+ * Displays a tile as a single cell in a table.
+ */
+public class TileSimpleTag extends SimpleTagSupport {
+    private String color;
+    private String label;
+
+    public void doTag() throws JspException, IOException {
+	getJspContext().getOut().write( 
+	    "&lt;td width=\"32\" height=\"32\" bgcolor=\"" + this.color + 
+	    "\">&lt;font color=\"#ffffff\">&lt;center>" + this.label + 
+                "&lt;/center>&lt;/font>&lt;/td>" );
+    }
+
+    public void setColor( String color ) {
+        this.color = color;
+    }
+    
+    public void setLabel( String label ) {
+        this.label = label;
+    }
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/jspattribute.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/jspattribute.html
new file mode 100644
index 0000000..b949da9
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/jspattribute.html
@@ -0,0 +1,37 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="jspattribute.jsp"><img src="../../images/execute.gif" align="right" border="0"></a>
+<a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="jspattribute.jsp.html">Source Code for jspattribute.jsp<font color="#0000FF"></a>
+  </font> </h3>
+
+<h3><a href="HelloWorldSimpleTag.java.html">Source Code for HelloWorldSimpleTag.java<font color="#0000FF"></a>
+  </font> </h3>
+
+<h3><a href="FooBean.java.html">Source Code for FooBean.java<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/jspattribute.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/jspattribute.jsp
new file mode 100644
index 0000000..64b6d6e
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/jspattribute.jsp
@@ -0,0 +1,46 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="my" uri="http://tomcat.apache.org/jsp2-example-taglib"%>
+
+<html>
+  <head>
+    <title>JSP 2.0 Examples - jsp:attribute and jsp:body</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Examples - jsp:attribute and jsp:body</h1>
+    <hr>
+    <p>The new &lt;jsp:attribute&gt; and &lt;jsp:body&gt; 
+    standard actions can be used to specify the value of any standard
+    action or custom action attribute.</p>
+    <p>This example uses the &lt;jsp:attribute&gt;
+    standard action to use the output of a custom action invocation
+    (one that simply outputs "Hello, World!") to set the value of a
+    bean property.  This would normally require an intermediary
+    step, such as using JSTL's &lt;c:set&gt; action.</p>
+    <br>
+    <jsp:useBean id="foo" class="jsp2.examples.FooBean">
+      Bean created!  Setting foo.bar...<br>
+      <jsp:setProperty name="foo" property="bar">
+        <jsp:attribute name="value">
+	  <my:helloWorld/>
+        </jsp:attribute>
+      </jsp:setProperty>
+    </jsp:useBean>
+    <br>
+    Result: ${foo.bar}
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/jspattribute.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/jspattribute.jsp.html
new file mode 100644
index 0000000..eb3a927
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/jspattribute.jsp.html
@@ -0,0 +1,48 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="my" uri="http://tomcat.apache.org/jsp2-example-taglib"%>
+
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Examples - jsp:attribute and jsp:body&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Examples - jsp:attribute and jsp:body&lt;/h1>
+    &lt;hr>
+    &lt;p>The new &amp;lt;jsp:attribute&amp;gt; and &amp;lt;jsp:body&amp;gt; 
+    standard actions can be used to specify the value of any standard
+    action or custom action attribute.&lt;/p>
+    &lt;p>This example uses the &amp;lt;jsp:attribute&amp;gt;
+    standard action to use the output of a custom action invocation
+    (one that simply outputs "Hello, World!") to set the value of a
+    bean property.  This would normally require an intermediary
+    step, such as using JSTL's &amp;lt;c:set&amp;gt; action.&lt;/p>
+    &lt;br>
+    &lt;jsp:useBean id="foo" class="jsp2.examples.FooBean">
+      Bean created!  Setting foo.bar...&lt;br>
+      &lt;jsp:setProperty name="foo" property="bar">
+        &lt;jsp:attribute name="value">
+	  &lt;my:helloWorld/>
+        &lt;/jsp:attribute>
+      &lt;/jsp:setProperty>
+    &lt;/jsp:useBean>
+    &lt;br>
+    Result: ${foo.bar}
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/shuffle.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/shuffle.html
new file mode 100644
index 0000000..b7a4cb6
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/shuffle.html
@@ -0,0 +1,37 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="shuffle.jsp"><img src="../../images/execute.gif" align="right" border="0"></a>
+<a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="shuffle.jsp.html">Source Code for shuffle.jsp<font color="#0000FF"></a>
+  </font> </h3>
+
+<h3><a href="ShuffleSimpleTag.java.html">Source Code for ShuffleSimpleTag.java<font color="#0000FF"></a>
+  </font> </h3>
+
+<h3><a href="TileSimpleTag.java.html">Source Code for TileSimpleTag.java<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/shuffle.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/shuffle.jsp
new file mode 100644
index 0000000..2a318a7
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/shuffle.jsp
@@ -0,0 +1,90 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="my" uri="http://tomcat.apache.org/jsp2-example-taglib"%>
+
+<html>
+  <head>
+    <title>JSP 2.0 Examples - Shuffle Example</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Examples - Shuffle Example</h1>
+    <hr>
+    <p>Try reloading the page a few times.  Both the rows and the columns
+    are shuffled and appear different each time.</p>
+    <p>Here's how the code works.  The SimpleTag handler called 
+    &lt;my:shuffle&gt; accepts three attributes.  Each attribute is a 
+    JSP Fragment, meaning it is a fragment of JSP code that can be
+    dynamically executed by the shuffle tag handler on demand.  The 
+    shuffle tag handler executes the three fragments in a random order.
+    To shuffle both the rows and the columns, the shuffle tag is used
+    with itself as a parameter.</p>
+    <hr>
+    <blockquote>
+     <font color="#ffffff">
+      <table>
+        <my:shuffle>
+          <jsp:attribute name="fragment1">
+            <tr>
+              <my:shuffle>
+                <jsp:attribute name="fragment1">
+                  <my:tile color="#ff0000" label="A"/>
+                </jsp:attribute>
+                <jsp:attribute name="fragment2">
+                  <my:tile color="#00ff00" label="B"/>
+                </jsp:attribute>
+                <jsp:attribute name="fragment3">
+                  <my:tile color="#0000ff" label="C"/>
+                </jsp:attribute>
+              </my:shuffle>
+            </tr>
+          </jsp:attribute>
+          <jsp:attribute name="fragment2">
+            <tr>
+              <my:shuffle>
+                <jsp:attribute name="fragment1">
+                  <my:tile color="#ff0000" label="1"/>
+                </jsp:attribute>
+                <jsp:attribute name="fragment2">
+                  <my:tile color="#00ff00" label="2"/>
+                </jsp:attribute>
+                <jsp:attribute name="fragment3">
+                  <my:tile color="#0000ff" label="3"/>
+                </jsp:attribute>
+              </my:shuffle>
+            </tr>
+          </jsp:attribute>
+          <jsp:attribute name="fragment3">
+            <tr>
+              <my:shuffle>
+                <jsp:attribute name="fragment1">
+                  <my:tile color="#ff0000" label="!"/>
+                </jsp:attribute>
+                <jsp:attribute name="fragment2">
+                  <my:tile color="#00ff00" label="@"/>
+                </jsp:attribute>
+                <jsp:attribute name="fragment3">
+                  <my:tile color="#0000ff" label="#"/>
+                </jsp:attribute>
+              </my:shuffle>
+            </tr>
+          </jsp:attribute>
+        </my:shuffle>
+      </table>
+     </font>
+    </blockquote>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/shuffle.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/shuffle.jsp.html
new file mode 100644
index 0000000..9329285
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspattribute/shuffle.jsp.html
@@ -0,0 +1,92 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="my" uri="http://tomcat.apache.org/jsp2-example-taglib"%>
+
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Examples - Shuffle Example&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Examples - Shuffle Example&lt;/h1>
+    &lt;hr>
+    &lt;p>Try reloading the page a few times.  Both the rows and the columns
+    are shuffled and appear different each time.&lt;/p>
+    &lt;p>Here's how the code works.  The SimpleTag handler called 
+    &amp;lt;my:shuffle&amp;gt; accepts three attributes.  Each attribute is a 
+    JSP Fragment, meaning it is a fragment of JSP code that can be
+    dynamically executed by the shuffle tag handler on demand.  The 
+    shuffle tag handler executes the three fragments in a random order.
+    To shuffle both the rows and the columns, the shuffle tag is used
+    with itself as a parameter.&lt;/p>
+    &lt;hr>
+    &lt;blockquote>
+     &lt;font color="#ffffff">
+      &lt;table>
+        &lt;my:shuffle>
+          &lt;jsp:attribute name="fragment1">
+            &lt;tr>
+              &lt;my:shuffle>
+                &lt;jsp:attribute name="fragment1">
+                  &lt;my:tile color="#ff0000" label="A"/>
+                &lt;/jsp:attribute>
+                &lt;jsp:attribute name="fragment2">
+                  &lt;my:tile color="#00ff00" label="B"/>
+                &lt;/jsp:attribute>
+                &lt;jsp:attribute name="fragment3">
+                  &lt;my:tile color="#0000ff" label="C"/>
+                &lt;/jsp:attribute>
+              &lt;/my:shuffle>
+            &lt;/tr>
+          &lt;/jsp:attribute>
+          &lt;jsp:attribute name="fragment2">
+            &lt;tr>
+              &lt;my:shuffle>
+                &lt;jsp:attribute name="fragment1">
+                  &lt;my:tile color="#ff0000" label="1"/>
+                &lt;/jsp:attribute>
+                &lt;jsp:attribute name="fragment2">
+                  &lt;my:tile color="#00ff00" label="2"/>
+                &lt;/jsp:attribute>
+                &lt;jsp:attribute name="fragment3">
+                  &lt;my:tile color="#0000ff" label="3"/>
+                &lt;/jsp:attribute>
+              &lt;/my:shuffle>
+            &lt;/tr>
+          &lt;/jsp:attribute>
+          &lt;jsp:attribute name="fragment3">
+            &lt;tr>
+              &lt;my:shuffle>
+                &lt;jsp:attribute name="fragment1">
+                  &lt;my:tile color="#ff0000" label="!"/>
+                &lt;/jsp:attribute>
+                &lt;jsp:attribute name="fragment2">
+                  &lt;my:tile color="#00ff00" label="@"/>
+                &lt;/jsp:attribute>
+                &lt;jsp:attribute name="fragment3">
+                  &lt;my:tile color="#0000ff" label="#"/>
+                &lt;/jsp:attribute>
+              &lt;/my:shuffle>
+            &lt;/tr>
+          &lt;/jsp:attribute>
+        &lt;/my:shuffle>
+      &lt;/table>
+     &lt;/font>
+    &lt;/blockquote>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspx/basic.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/basic.html
new file mode 100644
index 0000000..2e58dff
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/basic.html
@@ -0,0 +1,31 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="basic.jspx"><img src="../../images/execute.gif" align="right" border="0"></a><a
+href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="basic.jspx.html">Source Code for XHTML Basic Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspx/basic.jspx b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/basic.jspx
new file mode 100644
index 0000000..8a5b27d
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/basic.jspx
@@ -0,0 +1,46 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<tags:xhtmlbasic xmlns:tags="urn:jsptagdir:/WEB-INF/tags"
+                 xmlns:jsp="http://java.sun.com/JSP/Page"
+                 xmlns:fmt="http://java.sun.com/jsp/jstl/fmt"
+		 xmlns="http://www.w3.org/1999/xhtml">
+  <jsp:directive.page contentType="text/html" />
+  <head>
+    <title>JSPX - XHTML Basic Example</title>
+  </head>
+  <body>
+    <h1>JSPX - XHTML Basic Example</h1>
+    <hr/>
+    This example illustrates how to use JSPX to produce an XHTML basic
+    document suitable for use with mobile phones, televisions, 
+    PDAs, vending machines, pagers, car navigation systems,
+    mobile game machines, digital book readers, smart watches, etc.
+    <p/>
+    JSPX lets you create dynamic documents in a pure XML syntax compatible
+    with existing XML tools.  The XML syntax in JSP 1.2 was awkward and
+    required &amp;lt;jsp:root&amp;gt; to be the root element of the document.
+    This is no longer the case in JSP 2.0.
+    <p/>
+    This particular example uses a tag file to produce the DOCTYPE and
+    namespace declarations to make the output of this page a valid XHTML
+    Basic document.
+    <p/>
+    Just to prove this is live, here's some dynamic content:
+    <jsp:useBean id="now" class="java.util.Date" />
+    <fmt:formatDate value="${now}" pattern="MMMM d, yyyy, H:mm:ss"/>
+  </body>
+</tags:xhtmlbasic>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspx/basic.jspx.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/basic.jspx.html
new file mode 100644
index 0000000..f177334
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/basic.jspx.html
@@ -0,0 +1,48 @@
+<html><body><pre>
+&lt;!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;tags:xhtmlbasic xmlns:tags="urn:jsptagdir:/WEB-INF/tags"
+                 xmlns:jsp="http://java.sun.com/JSP/Page"
+                 xmlns:fmt="http://java.sun.com/jsp/jstl/fmt"
+		 xmlns="http://www.w3.org/1999/xhtml">
+  &lt;jsp:directive.page contentType="text/html" />
+  &lt;head>
+    &lt;title>JSPX - XHTML Basic Example&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSPX - XHTML Basic Example&lt;/h1>
+    &lt;hr/>
+    This example illustrates how to use JSPX to produce an XHTML basic
+    document suitable for use with mobile phones, televisions, 
+    PDAs, vending machines, pagers, car navigation systems,
+    mobile game machines, digital book readers, smart watches, etc.
+    &lt;p/>
+    JSPX lets you create dynamic documents in a pure XML syntax compatible
+    with existing XML tools.  The XML syntax in JSP 1.2 was awkward and
+    required &amp;amp;lt;jsp:root&amp;amp;gt; to be the root element of the document.
+    This is no longer the case in JSP 2.0.
+    &lt;p/>
+    This particular example uses a tag file to produce the DOCTYPE and
+    namespace declarations to make the output of this page a valid XHTML
+    Basic document.
+    &lt;p/>
+    Just to prove this is live, here's some dynamic content:
+    &lt;jsp:useBean id="now" class="java.util.Date" />
+    &lt;fmt:formatDate value="${now}" pattern="MMMM d, yyyy, H:mm:ss"/>
+  &lt;/body>
+&lt;/tags:xhtmlbasic>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspx/svgexample.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/svgexample.html
new file mode 100644
index 0000000..12bcd82
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/svgexample.html
@@ -0,0 +1,52 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+  <head>
+    <title>JSP 2.0 SVG Example</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 SVG Example</h1>
+    <hr>
+    This example uses JSP 2.0's new, simplified JSPX syntax to render a
+    Scalable Vector Graphics (SVG) document.  When you view the source,
+    notice the lack of a &lt;jsp:root&gt; element!  The text to be rendered 
+    can be modified by changing the value of the name parameter.
+    <p>
+    SVG has many potential uses, such as searchable images, or images
+    customized with the name of your site's visitor (e.g. a "Susan's Store"
+    tab image).  JSPX is a natural fit for generating dynamic XML content
+    such as SVG.
+    <p>
+    To execute this example, follow these steps:
+    <ol>
+      <li>Download <a href="http://xmlgraphics.apache.org/batik/index.html">Apache Batik</a>,
+          or any other SVG viewer.</li>
+      <li>Copy the following URL:
+      <a href="http://localhost:8080/examples/jsp/jsp2/jspx/textRotate.jspx?name=JSPX">
+      http://localhost:8080/examples/jsp/jsp2/jspx/textRotate.jspx?name=JSPX</a>
+      </li>
+      <li>Paste the URL into Batik's Location field and press Enter</li>
+      <li>Customize by changing the name=JSPX parameter</li>
+    </ol>
+    <br>
+    The following is a screenshot of the resulting image, for those that
+    don't have an SVG viewer:
+    <blockquote>
+      <img src="textRotate.jpg" border="1">
+    </blockquote>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.html
new file mode 100644
index 0000000..e54588f
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.html
@@ -0,0 +1,32 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="textRotate.jspx"><img src="../../images/execute.gif" align="right" border="0"></a><a
+href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="textRotate.jspx.html">Source Code for SVG (Scalable Vector Graphics)
+Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.jpg b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.jpg
new file mode 100644
index 0000000..9e98736
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.jpg
Binary files differ
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.jspx b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.jspx
new file mode 100644
index 0000000..ad97af2
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.jspx
@@ -0,0 +1,52 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- 
+  - This example is based off the textRotate.svg example that comes
+  - with Apache Batik.  The original example was written by Bill Haneman.
+  - This version by Mark Roth.
+  -->
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="450" height="500" viewBox="0 0 450 500"
+     xmlns:c="http://java.sun.com/jsp/jstl/core"
+     xmlns:fn="http://java.sun.com/jsp/jstl/functions"
+     xmlns:jsp="http://java.sun.com/JSP/Page">
+  <jsp:directive.page contentType="image/svg+xml" />
+  <title>JSP 2.0 JSPX</title>
+  <!-- select name parameter, or default to JSPX -->
+  <c:set var="name" value='${empty fn:escapeXml(param["name"]) ? "JSPX" : fn:escapeXml(param["name"])}'/>
+  <g id="testContent">
+    <text class="title" x="50%" y="10%" font-size="15" text-anchor="middle" >
+            JSP 2.0 XML Syntax (.jspx) Demo</text>
+    <text class="title" x="50%" y="15%" font-size="15" text-anchor="middle" >
+            Try changing the name parameter!</text>
+    <g opacity="1.0" transform="translate(225, 250)" id="rotatedText">
+      <c:forEach var="i" begin="1" end="24">
+        <jsp:text>
+          <![CDATA[<g opacity="0.95" transform="scale(1.05) rotate(15)">]]>
+        </jsp:text>
+        <text x="0" y="0" transform="scale(1.6, 1.6)" fill="DarkSlateBlue" 
+              text-anchor="middle" font-size="40" font-family="Serif" 
+              id="words">${name}</text>
+      </c:forEach>
+      <c:forEach var="i" begin="1" end="24">
+        <jsp:text><![CDATA[</g>]]></jsp:text>
+      </c:forEach>
+      <text style="font-size:75;font-family:Serif;fill:white" 
+            text-anchor="middle">${name}</text>
+    </g>
+  </g>
+</svg>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.jspx.html b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.jspx.html
new file mode 100644
index 0000000..5846a19
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/jspx/textRotate.jspx.html
@@ -0,0 +1,54 @@
+<html><body><pre>
+&lt;!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;!-- 
+  - This example is based off the textRotate.svg example that comes
+  - with Apache Batik.  The original example was written by Bill Haneman.
+  - This version by Mark Roth.
+  -->
+&lt;svg xmlns="http://www.w3.org/2000/svg"
+     width="450" height="500" viewBox="0 0 450 500"
+     xmlns:c="http://java.sun.com/jsp/jstl/core"
+     xmlns:fn="http://java.sun.com/jsp/jstl/functions"
+     xmlns:jsp="http://java.sun.com/JSP/Page">
+  &lt;jsp:directive.page contentType="image/svg+xml" />
+  &lt;title>JSP 2.0 JSPX&lt;/title>
+  &lt;!-- select name parameter, or default to JSPX -->
+  &lt;c:set var="name" value='${empty fn:escapeXml(param["name"]) ? "JSPX" : fn:escapeXml(param["name"])}'/>
+  &lt;g id="testContent">
+    &lt;text class="title" x="50%" y="10%" font-size="15" text-anchor="middle" >
+            JSP 2.0 XML Syntax (.jspx) Demo&lt;/text>
+    &lt;text class="title" x="50%" y="15%" font-size="15" text-anchor="middle" >
+            Try changing the name parameter!&lt;/text>
+    &lt;g opacity="1.0" transform="translate(225, 250)" id="rotatedText">
+      &lt;c:forEach var="i" begin="1" end="24">
+        &lt;jsp:text>
+          &lt;![CDATA[&lt;g opacity="0.95" transform="scale(1.05) rotate(15)">]]>
+        &lt;/jsp:text>
+        &lt;text x="0" y="0" transform="scale(1.6, 1.6)" fill="DarkSlateBlue" 
+              text-anchor="middle" font-size="40" font-family="Serif" 
+              id="words">${name}&lt;/text>
+      &lt;/c:forEach>
+      &lt;c:forEach var="i" begin="1" end="24">
+        &lt;jsp:text>&lt;![CDATA[&lt;/g>]]>&lt;/jsp:text>
+      &lt;/c:forEach>
+      &lt;text style="font-size:75;font-family:Serif;fill:white" 
+            text-anchor="middle">${name}&lt;/text>
+    &lt;/g>
+  &lt;/g>
+&lt;/svg>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/EchoAttributesTag.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/misc/EchoAttributesTag.java.html
new file mode 100644
index 0000000..4e62250
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/EchoAttributesTag.java.html
@@ -0,0 +1,56 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+package jsp2.examples.simpletag;
+
+import javax.servlet.jsp.JspException;
+import javax.servlet.jsp.JspWriter;
+import javax.servlet.jsp.tagext.SimpleTagSupport;
+import javax.servlet.jsp.tagext.DynamicAttributes;
+import java.util.ArrayList;
+import java.io.IOException;
+
+/**
+ * SimpleTag handler that echoes all its attributes 
+ */
+public class EchoAttributesTag 
+    extends SimpleTagSupport
+    implements DynamicAttributes
+{
+    private ArrayList keys = new ArrayList();
+    private ArrayList values = new ArrayList();
+
+    public void doTag() throws JspException, IOException {
+	JspWriter out = getJspContext().getOut();
+	for( int i = 0; i &lt; keys.size(); i++ ) {
+	    String key = (String)keys.get( i );
+	    Object value = values.get( i );
+	    out.println( "&lt;li>" + key + " = " + value + "&lt;/li>" );
+        }
+    }
+
+    public void setDynamicAttribute( String uri, String localName, 
+	Object value ) 
+	throws JspException
+    {
+	keys.add( localName );
+	values.add( value );
+    }
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/coda.jspf b/tomcat-uid/webapps/examples/jsp/jsp2/misc/coda.jspf
new file mode 100644
index 0000000..20de7f6
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/coda.jspf
@@ -0,0 +1,21 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<hr>
+<center>
+This banner included with &lt;include-coda&gt;
+</center>
+<hr>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/coda.jspf.html b/tomcat-uid/webapps/examples/jsp/jsp2/misc/coda.jspf.html
new file mode 100644
index 0000000..ef5a1b3
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/coda.jspf.html
@@ -0,0 +1,23 @@
+<html><body><pre>
+&lt;!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;hr>
+&lt;center>
+This banner included with &amp;lt;include-coda&amp;gt;
+&lt;/center>
+&lt;hr>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/config.html b/tomcat-uid/webapps/examples/jsp/jsp2/misc/config.html
new file mode 100644
index 0000000..ebd2f4c
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/config.html
@@ -0,0 +1,35 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="config.jsp"><img src="../../images/execute.gif" align="right" border="0"></a>
+<a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="config.jsp.html">Source Code for config.jsp<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="prelude.jspf.html">Source Code for prelude.jspf<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="coda.jspf.html">Source Code for coda.jspf<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/config.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/misc/config.jsp
new file mode 100644
index 0000000..7ccf481
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/config.jsp
@@ -0,0 +1,32 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="my" uri="http://tomcat.apache.org/jsp2-example-taglib"%>
+    <h1>JSP 2.0 Examples - JSP Configuration</h1>
+    <hr>
+    <p>Using a &lt;jsp-property-group&gt; element in the web.xml 
+    deployment descriptor, this JSP page has been configured in the
+    following ways:</p>
+    <ul>
+      <li>Uses &lt;include-prelude&gt; to include the top banner.</li>
+      <li>Uses &lt;include-coda&gt; to include the bottom banner.</li>
+      <li>Uses &lt;scripting-invalid&gt; true to disable 
+	  &lt;% scripting %&gt; elements</li>
+      <li>Uses &lt;el-ignored&gt; true to disable ${EL} elements</li>
+      <li>Uses &lt;page-encoding&gt; ISO-8859-1 to set the page encoding (though this is the default anyway)</li>
+    </ul>
+    There are various other configuration options that can be used.
+
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/config.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/misc/config.jsp.html
new file mode 100644
index 0000000..033f2d2
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/config.jsp.html
@@ -0,0 +1,34 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="my" uri="http://tomcat.apache.org/jsp2-example-taglib"%>
+    &lt;h1>JSP 2.0 Examples - JSP Configuration&lt;/h1>
+    &lt;hr>
+    &lt;p>Using a &amp;lt;jsp-property-group&amp;gt; element in the web.xml 
+    deployment descriptor, this JSP page has been configured in the
+    following ways:&lt;/p>
+    &lt;ul>
+      &lt;li>Uses &amp;lt;include-prelude&amp;gt; to include the top banner.&lt;/li>
+      &lt;li>Uses &amp;lt;include-coda&amp;gt; to include the bottom banner.&lt;/li>
+      &lt;li>Uses &amp;lt;scripting-invalid&amp;gt; true to disable 
+	  &amp;lt;% scripting %&amp;gt; elements&lt;/li>
+      &lt;li>Uses &amp;lt;el-ignored&amp;gt; true to disable ${EL} elements&lt;/li>
+      &lt;li>Uses &amp;lt;page-encoding&amp;gt; ISO-8859-1 to set the page encoding (though this is the default anyway)&lt;/li>
+    &lt;/ul>
+    There are various other configuration options that can be used.
+
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/dynamicattrs.html b/tomcat-uid/webapps/examples/jsp/jsp2/misc/dynamicattrs.html
new file mode 100644
index 0000000..a02a987
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/dynamicattrs.html
@@ -0,0 +1,33 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="dynamicattrs.jsp"><img src="../../images/execute.gif" align="right" border="0"></a>
+<a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="dynamicattrs.jsp.html">Source Code for dynamicattrs.jsp<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="EchoAttributesTag.java.html">Source Code for EchoAttributesTag.java<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/dynamicattrs.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/misc/dynamicattrs.jsp
new file mode 100644
index 0000000..637dea9
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/dynamicattrs.jsp
@@ -0,0 +1,44 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="my" uri="http://tomcat.apache.org/jsp2-example-taglib"%>
+<html>
+  <head>
+    <title>JSP 2.0 Examples - Dynamic Attributes</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Examples - Dynamic Attributes</h1>
+    <hr>
+    <p>This JSP page invokes a custom tag that accepts a dynamic set 
+    of attributes.  The tag echoes the name and value of all attributes
+    passed to it.</p>
+    <hr>
+    <h2>Invocation 1 (six attributes)</h2>
+    <ul>
+      <my:echoAttributes x="1" y="2" z="3" r="red" g="green" b="blue"/>
+    </ul>
+    <h2>Invocation 2 (zero attributes)</h2>
+    <ul>
+      <my:echoAttributes/>
+    </ul>
+    <h2>Invocation 3 (three attributes)</h2>
+    <ul>
+      <my:echoAttributes dogName="Scruffy" 
+	   		 catName="Fluffy" 
+			 blowfishName="Puffy"/>
+    </ul>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/dynamicattrs.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/misc/dynamicattrs.jsp.html
new file mode 100644
index 0000000..ec47c8c
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/dynamicattrs.jsp.html
@@ -0,0 +1,46 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="my" uri="http://tomcat.apache.org/jsp2-example-taglib"%>
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Examples - Dynamic Attributes&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Examples - Dynamic Attributes&lt;/h1>
+    &lt;hr>
+    &lt;p>This JSP page invokes a custom tag that accepts a dynamic set 
+    of attributes.  The tag echoes the name and value of all attributes
+    passed to it.&lt;/p>
+    &lt;hr>
+    &lt;h2>Invocation 1 (six attributes)&lt;/h2>
+    &lt;ul>
+      &lt;my:echoAttributes x="1" y="2" z="3" r="red" g="green" b="blue"/>
+    &lt;/ul>
+    &lt;h2>Invocation 2 (zero attributes)&lt;/h2>
+    &lt;ul>
+      &lt;my:echoAttributes/>
+    &lt;/ul>
+    &lt;h2>Invocation 3 (three attributes)&lt;/h2>
+    &lt;ul>
+      &lt;my:echoAttributes dogName="Scruffy" 
+	   		 catName="Fluffy" 
+			 blowfishName="Puffy"/>
+    &lt;/ul>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/prelude.jspf b/tomcat-uid/webapps/examples/jsp/jsp2/misc/prelude.jspf
new file mode 100644
index 0000000..9772e1c
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/prelude.jspf
@@ -0,0 +1,21 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<hr>
+<center>
+This banner included with &lt;include-prelude&gt;
+</center>
+<hr>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/misc/prelude.jspf.html b/tomcat-uid/webapps/examples/jsp/jsp2/misc/prelude.jspf.html
new file mode 100644
index 0000000..f928f18
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/misc/prelude.jspf.html
@@ -0,0 +1,23 @@
+<html><body><pre>
+&lt;!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;hr>
+&lt;center>
+This banner included with &amp;lt;include-prelude&amp;gt;
+&lt;/center>
+&lt;hr>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/BookBean.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/BookBean.java.html
new file mode 100644
index 0000000..a977a8c
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/BookBean.java.html
@@ -0,0 +1,46 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+package jsp2.examples;
+
+public class BookBean {
+    private String title;
+    private String author;
+    private String isbn;
+    
+    public BookBean( String title, String author, String isbn ) {
+        this.title = title;
+        this.author = author;
+        this.isbn = isbn;
+    }
+
+    public String getTitle() {
+        return this.title;
+    }
+    
+    public String getAuthor() {
+        return this.author;
+    }
+    
+    public String getIsbn() {
+        return this.isbn;
+    }
+    
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/FindBookSimpleTag.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/FindBookSimpleTag.java.html
new file mode 100644
index 0000000..d010f0a
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/FindBookSimpleTag.java.html
@@ -0,0 +1,46 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+package jsp2.examples.simpletag;
+
+import javax.servlet.jsp.JspException;
+import javax.servlet.jsp.tagext.SimpleTagSupport;
+import jsp2.examples.BookBean;
+
+/**
+ * SimpleTag handler that pretends to search for a book, and stores
+ * the result in a scoped variable.
+ */
+public class FindBookSimpleTag extends SimpleTagSupport {
+    private String var;
+    
+    private static final String BOOK_TITLE = "The Lord of the Rings";
+    private static final String BOOK_AUTHOR = "J. R. R. Tolkein";
+    private static final String BOOK_ISBN = "0618002251";
+
+    public void doTag() throws JspException {
+        BookBean book = new BookBean( BOOK_TITLE, BOOK_AUTHOR, BOOK_ISBN );
+        getJspContext().setAttribute( this.var, book );
+    }
+
+    public void setVar( String var ) {
+	this.var = var;
+    }
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/Functions.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/Functions.java.html
new file mode 100644
index 0000000..350fce6
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/Functions.java.html
@@ -0,0 +1,45 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package jsp2.examples.el;
+
+/**
+ * Defines the functions for the jsp2 example tag library.
+ * 
+ * &lt;p>Each function is defined as a static method.&lt;/p>
+ */
+public class Functions {
+    public static String reverse( String text ) {
+        return new StringBuffer( text ).reverse().toString();
+    }
+
+    public static int numVowels( String text ) {
+        String vowels = "aeiouAEIOU";
+	int result = 0;
+        for( int i = 0; i &lt; text.length(); i++ ) {
+	    if( vowels.indexOf( text.charAt( i ) ) != -1 ) {
+	        result++;
+	    }
+	}
+	return result;
+    }
+
+    public static String caps( String text ) {
+        return text.toUpperCase();
+    }
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/HelloWorldSimpleTag.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/HelloWorldSimpleTag.java.html
new file mode 100644
index 0000000..c409839
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/HelloWorldSimpleTag.java.html
@@ -0,0 +1,34 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+package jsp2.examples.simpletag;
+
+import javax.servlet.jsp.JspException;
+import javax.servlet.jsp.tagext.SimpleTagSupport;
+import java.io.IOException;
+
+/**
+ * SimpleTag handler that prints "Hello, world!"
+ */
+public class HelloWorldSimpleTag extends SimpleTagSupport {
+    public void doTag() throws JspException, IOException {
+	getJspContext().getOut().write( "Hello, world!" );
+    }
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/RepeatSimpleTag.java.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/RepeatSimpleTag.java.html
new file mode 100644
index 0000000..2ad96eb
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/RepeatSimpleTag.java.html
@@ -0,0 +1,44 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+package jsp2.examples.simpletag;
+
+import javax.servlet.jsp.JspException;
+import javax.servlet.jsp.tagext.SimpleTagSupport;
+import java.io.IOException;
+
+/**
+ * SimpleTag handler that accepts a num attribute and 
+ * invokes its body 'num' times.
+ */
+public class RepeatSimpleTag extends SimpleTagSupport {
+    private int num;
+
+    public void doTag() throws JspException, IOException {
+        for (int i=0; i&lt;num; i++) {
+            getJspContext().setAttribute("count", String.valueOf( i + 1 ) );
+	    getJspBody().invoke(null);
+        }
+    }
+
+    public void setNum(int num) {
+	this.num = num;
+    }
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/book.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/book.html
new file mode 100644
index 0000000..62cf284
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/book.html
@@ -0,0 +1,37 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="book.jsp"><img src="../../images/execute.gif" align="right" border="0"></a>
+<a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="book.jsp.html">Source Code for the Book Example JSP<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="FindBookSimpleTag.java.html">Source Code for the FindBook SimpleTag Handler<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="BookBean.java.html">Source Code for BookBean<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="Functions.java.html">Source Code for the EL Functions<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/book.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/book.jsp
new file mode 100644
index 0000000..7a9a064
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/book.jsp
@@ -0,0 +1,55 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="my" uri="/WEB-INF/jsp2/jsp2-example-taglib.tld" %>
+<html>
+  <head>
+    <title>JSP 2.0 Examples - Book SimpleTag Handler</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Examples - Book SimpleTag Handler</h1>
+    <hr>
+    <p>Illustrates a semi-realistic use of SimpleTag and the Expression 
+    Language.  First, a &lt;my:findBook&gt; tag is invoked to populate 
+    the page context with a BookBean.  Then, the books fields are printed 
+    in all caps.</p>
+    <br>
+    <b><u>Result:</u></b><br>
+    <my:findBook var="book"/>
+    <table border="1">
+        <thead>
+	    <td><b>Field</b></td>
+	    <td><b>Value</b></td>
+	    <td><b>Capitalized</b></td>
+	</thead>
+	<tr>
+	    <td>Title</td>
+	    <td>${book.title}</td>
+	    <td>${my:caps(book.title)}</td>
+	</tr>
+	<tr>
+	    <td>Author</td>
+	    <td>${book.author}</td>
+	    <td>${my:caps(book.author)}</td>
+	</tr>
+	<tr>
+	    <td>ISBN</td>
+	    <td>${book.isbn}</td>
+	    <td>${my:caps(book.isbn)}</td>
+	</tr>
+    </table>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/book.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/book.jsp.html
new file mode 100644
index 0000000..7ecfe3b
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/book.jsp.html
@@ -0,0 +1,57 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="my" uri="/WEB-INF/jsp2/jsp2-example-taglib.tld" %>
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Examples - Book SimpleTag Handler&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Examples - Book SimpleTag Handler&lt;/h1>
+    &lt;hr>
+    &lt;p>Illustrates a semi-realistic use of SimpleTag and the Expression 
+    Language.  First, a &amp;lt;my:findBook&amp;gt; tag is invoked to populate 
+    the page context with a BookBean.  Then, the books fields are printed 
+    in all caps.&lt;/p>
+    &lt;br>
+    &lt;b>&lt;u>Result:&lt;/u>&lt;/b>&lt;br>
+    &lt;my:findBook var="book"/>
+    &lt;table border="1">
+        &lt;thead>
+	    &lt;td>&lt;b>Field&lt;/b>&lt;/td>
+	    &lt;td>&lt;b>Value&lt;/b>&lt;/td>
+	    &lt;td>&lt;b>Capitalized&lt;/b>&lt;/td>
+	&lt;/thead>
+	&lt;tr>
+	    &lt;td>Title&lt;/td>
+	    &lt;td>${book.title}&lt;/td>
+	    &lt;td>${my:caps(book.title)}&lt;/td>
+	&lt;/tr>
+	&lt;tr>
+	    &lt;td>Author&lt;/td>
+	    &lt;td>${book.author}&lt;/td>
+	    &lt;td>${my:caps(book.author)}&lt;/td>
+	&lt;/tr>
+	&lt;tr>
+	    &lt;td>ISBN&lt;/td>
+	    &lt;td>${book.isbn}&lt;/td>
+	    &lt;td>${my:caps(book.isbn)}&lt;/td>
+	&lt;/tr>
+    &lt;/table>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/hello.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/hello.html
new file mode 100644
index 0000000..1e7dfcb
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/hello.html
@@ -0,0 +1,33 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="hello.jsp"><img src="../../images/execute.gif" align="right" border="0"></a>
+<a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="hello.jsp.html">Source Code for the Hello World Tag Example JSP<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="HelloWorldSimpleTag.java.html">Source Code for the Hello World SimpleTag Handler<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/hello.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/hello.jsp
new file mode 100644
index 0000000..4222b2e
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/hello.jsp
@@ -0,0 +1,31 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="mytag" uri="/WEB-INF/jsp2/jsp2-example-taglib.tld" %>
+<html>
+  <head>
+    <title>JSP 2.0 Examples - Hello World SimpleTag Handler</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Examples - Hello World SimpleTag Handler</h1>
+    <hr>
+    <p>This tag handler simply echos "Hello, World!"  It's an example of
+    a very basic SimpleTag handler with no body.</p>
+    <br>
+    <b><u>Result:</u></b>
+    <mytag:helloWorld/>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/hello.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/hello.jsp.html
new file mode 100644
index 0000000..c363802
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/hello.jsp.html
@@ -0,0 +1,33 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="mytag" uri="/WEB-INF/jsp2/jsp2-example-taglib.tld" %>
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Examples - Hello World SimpleTag Handler&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Examples - Hello World SimpleTag Handler&lt;/h1>
+    &lt;hr>
+    &lt;p>This tag handler simply echos "Hello, World!"  It's an example of
+    a very basic SimpleTag handler with no body.&lt;/p>
+    &lt;br>
+    &lt;b>&lt;u>Result:&lt;/u>&lt;/b>
+    &lt;mytag:helloWorld/>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/repeat.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/repeat.html
new file mode 100644
index 0000000..18ff5ed
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/repeat.html
@@ -0,0 +1,33 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="repeat.jsp"><img src="../../images/execute.gif" align="right" border="0"></a>
+<a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="repeat.jsp.html">Source Code for the Repeat Tag Example JSP<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="RepeatSimpleTag.java.html">Source Code for the Repeat SimpleTag Handler<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/repeat.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/repeat.jsp
new file mode 100644
index 0000000..1f3d008
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/repeat.jsp
@@ -0,0 +1,39 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="mytag" uri="/WEB-INF/jsp2/jsp2-example-taglib.tld" %>
+<html>
+  <head>
+    <title>JSP 2.0 Examples - Repeat SimpleTag Handler</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Examples - Repeat SimpleTag Handler</h1>
+    <hr>
+    <p>This tag handler accepts a "num" parameter and repeats the body of the
+    tag "num" times.  It's a simple example, but the implementation of 
+    such a tag in JSP 2.0 is substantially simpler than the equivalent 
+    JSP 1.2-style classic tag handler.</p>
+    <p>The body of the tag is encapsulated in a "JSP Fragment" and passed
+    to the tag handler, which then executes it five times, inside a 
+    for loop.  The tag handler passes in the current invocation in a
+    scoped variable called count, which can be accessed using the EL.</p>
+    <br>
+    <b><u>Result:</u></b><br>
+    <mytag:repeat num="5">
+      Invocation ${count} of 5<br>
+    </mytag:repeat>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/repeat.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/repeat.jsp.html
new file mode 100644
index 0000000..e36b66c
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/simpletag/repeat.jsp.html
@@ -0,0 +1,41 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="mytag" uri="/WEB-INF/jsp2/jsp2-example-taglib.tld" %>
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Examples - Repeat SimpleTag Handler&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Examples - Repeat SimpleTag Handler&lt;/h1>
+    &lt;hr>
+    &lt;p>This tag handler accepts a "num" parameter and repeats the body of the
+    tag "num" times.  It's a simple example, but the implementation of 
+    such a tag in JSP 2.0 is substantially simpler than the equivalent 
+    JSP 1.2-style classic tag handler.&lt;/p>
+    &lt;p>The body of the tag is encapsulated in a "JSP Fragment" and passed
+    to the tag handler, which then executes it five times, inside a 
+    for loop.  The tag handler passes in the current invocation in a
+    scoped variable called count, which can be accessed using the EL.&lt;/p>
+    &lt;br>
+    &lt;b>&lt;u>Result:&lt;/u>&lt;/b>&lt;br>
+    &lt;mytag:repeat num="5">
+      Invocation ${count} of 5&lt;br>
+    &lt;/mytag:repeat>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/displayProducts.tag.html b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/displayProducts.tag.html
new file mode 100644
index 0000000..6388336
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/displayProducts.tag.html
@@ -0,0 +1,57 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+&lt;%@ attribute name="normalPrice" fragment="true" %>
+&lt;%@ attribute name="onSale" fragment="true" %>
+&lt;%@ variable name-given="name" %>
+&lt;%@ variable name-given="price" %>
+&lt;%@ variable name-given="origPrice" %>
+&lt;%@ variable name-given="salePrice" %>
+
+&lt;table border="1">
+  &lt;tr>
+    &lt;td> 
+      &lt;c:set var="name" value="Hand-held Color PDA"/>
+      &lt;c:set var="price" value="$298.86"/>
+      &lt;jsp:invoke fragment="normalPrice"/>
+    &lt;/td>
+    &lt;td> 
+      &lt;c:set var="name" value="4-Pack 150 Watt Light Bulbs"/>
+      &lt;c:set var="origPrice" value="$2.98"/>
+      &lt;c:set var="salePrice" value="$2.32"/>
+      &lt;jsp:invoke fragment="onSale"/>
+    &lt;/td>
+    &lt;td> 
+      &lt;c:set var="name" value="Digital Cellular Phone"/>
+      &lt;c:set var="price" value="$68.74"/>
+      &lt;jsp:invoke fragment="normalPrice"/>
+    &lt;/td>
+    &lt;td> 
+      &lt;c:set var="name" value="Baby Grand Piano"/>
+      &lt;c:set var="price" value="$10,800.00"/>
+      &lt;jsp:invoke fragment="normalPrice"/>
+    &lt;/td>
+    &lt;td> 
+      &lt;c:set var="name" value="Luxury Car w/ Leather Seats"/>
+      &lt;c:set var="origPrice" value="$23,980.00"/>
+      &lt;c:set var="salePrice" value="$21,070.00"/>
+      &lt;jsp:invoke fragment="onSale"/>
+    &lt;/td>
+  &lt;/tr>
+&lt;/table>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/hello.html b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/hello.html
new file mode 100644
index 0000000..aab12a7
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/hello.html
@@ -0,0 +1,33 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="hello.jsp"><img src="../../images/execute.gif" align="right" border="0"></a>
+<a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="hello.jsp.html">Source Code for hello.jsp<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="helloWorld.tag.html">Source Code for helloWorld.tag<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/hello.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/hello.jsp
new file mode 100644
index 0000000..e93c7c5
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/hello.jsp
@@ -0,0 +1,35 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="tags" tagdir="/WEB-INF/tags" %>
+<html>
+  <head>
+    <title>JSP 2.0 Examples - Hello World Using a Tag File</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Examples - Hello World Using a Tag File</h1>
+    <hr>
+    <p>This JSP page invokes a custom tag that simply echos "Hello, World!"  
+    The custom tag is generated from a tag file in the /WEB-INF/tags
+    directory.</p>
+    <p>Notice that we did not need to write a TLD for this tag.  We just
+    created /WEB-INF/tags/helloWorld.tag, imported it using the taglib
+    directive, and used it!</p>
+    <br>
+    <b><u>Result:</u></b>
+    <tags:helloWorld/>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/hello.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/hello.jsp.html
new file mode 100644
index 0000000..c3b7b4f
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/hello.jsp.html
@@ -0,0 +1,37 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="tags" tagdir="/WEB-INF/tags" %>
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Examples - Hello World Using a Tag File&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Examples - Hello World Using a Tag File&lt;/h1>
+    &lt;hr>
+    &lt;p>This JSP page invokes a custom tag that simply echos "Hello, World!"  
+    The custom tag is generated from a tag file in the /WEB-INF/tags
+    directory.&lt;/p>
+    &lt;p>Notice that we did not need to write a TLD for this tag.  We just
+    created /WEB-INF/tags/helloWorld.tag, imported it using the taglib
+    directive, and used it!&lt;/p>
+    &lt;br>
+    &lt;b>&lt;u>Result:&lt;/u>&lt;/b>
+    &lt;tags:helloWorld/>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/helloWorld.tag.html b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/helloWorld.tag.html
new file mode 100644
index 0000000..e335986
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/helloWorld.tag.html
@@ -0,0 +1,19 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+Hello, world!
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.html b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.html
new file mode 100644
index 0000000..161b70d
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.html
@@ -0,0 +1,33 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="panel.jsp"><img src="../../images/execute.gif" align="right" border="0"></a>
+<a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="panel.jsp.html">Source Code for panel.jsp<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="panel.tag.html">Source Code for panel.tag<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.jsp
new file mode 100644
index 0000000..4dfc483
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.jsp
@@ -0,0 +1,58 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="tags" tagdir="/WEB-INF/tags" %>
+<html>
+  <head>
+    <title>JSP 2.0 Examples - Panels using Tag Files</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Examples - Panels using Tag Files</h1>
+    <hr>
+    <p>This JSP page invokes a custom tag that draws a 
+    panel around the contents of the tag body.  Normally, such a tag 
+    implementation would require a Java class with many println() statements,
+    outputting HTML.  Instead, we can use a .tag file as a template,
+    and we don't need to write a single line of Java or even a TLD!</p>
+    <hr>
+    <table border="0">
+      <tr valign="top">
+        <td>
+          <tags:panel color="#ff8080" bgcolor="#ffc0c0" title="Panel 1">
+	    First panel.<br/>
+	  </tags:panel>
+        </td>
+        <td>
+          <tags:panel color="#80ff80" bgcolor="#c0ffc0" title="Panel 2">
+	    Second panel.<br/>
+	    Second panel.<br/>
+	    Second panel.<br/>
+	    Second panel.<br/>
+	  </tags:panel>
+        </td>
+        <td>
+          <tags:panel color="#8080ff" bgcolor="#c0c0ff" title="Panel 3">
+	    Third panel.<br/>
+            <tags:panel color="#ff80ff" bgcolor="#ffc0ff" title="Inner">
+	      A panel in a panel.
+	    </tags:panel>
+	    Third panel.<br/>
+	  </tags:panel>
+        </td>
+      </tr>
+    </table>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.jsp.html
new file mode 100644
index 0000000..0cc746d
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.jsp.html
@@ -0,0 +1,60 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="tags" tagdir="/WEB-INF/tags" %>
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Examples - Panels using Tag Files&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Examples - Panels using Tag Files&lt;/h1>
+    &lt;hr>
+    &lt;p>This JSP page invokes a custom tag that draws a 
+    panel around the contents of the tag body.  Normally, such a tag 
+    implementation would require a Java class with many println() statements,
+    outputting HTML.  Instead, we can use a .tag file as a template,
+    and we don't need to write a single line of Java or even a TLD!&lt;/p>
+    &lt;hr>
+    &lt;table border="0">
+      &lt;tr valign="top">
+        &lt;td>
+          &lt;tags:panel color="#ff8080" bgcolor="#ffc0c0" title="Panel 1">
+	    First panel.&lt;br/>
+	  &lt;/tags:panel>
+        &lt;/td>
+        &lt;td>
+          &lt;tags:panel color="#80ff80" bgcolor="#c0ffc0" title="Panel 2">
+	    Second panel.&lt;br/>
+	    Second panel.&lt;br/>
+	    Second panel.&lt;br/>
+	    Second panel.&lt;br/>
+	  &lt;/tags:panel>
+        &lt;/td>
+        &lt;td>
+          &lt;tags:panel color="#8080ff" bgcolor="#c0c0ff" title="Panel 3">
+	    Third panel.&lt;br/>
+            &lt;tags:panel color="#ff80ff" bgcolor="#ffc0ff" title="Inner">
+	      A panel in a panel.
+	    &lt;/tags:panel>
+	    Third panel.&lt;br/>
+	  &lt;/tags:panel>
+        &lt;/td>
+      &lt;/tr>
+    &lt;/table>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.tag.html b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.tag.html
new file mode 100644
index 0000000..df1c214
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/panel.tag.html
@@ -0,0 +1,31 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ attribute name="color" %>
+&lt;%@ attribute name="bgcolor" %>
+&lt;%@ attribute name="title" %>
+&lt;table border="1" bgcolor="${color}">
+  &lt;tr>
+    &lt;td>&lt;b>${title}&lt;/b>&lt;/td>
+  &lt;/tr>
+  &lt;tr>
+    &lt;td bgcolor="${bgcolor}">
+      &lt;jsp:doBody/>
+    &lt;/td>
+  &lt;/tr>
+&lt;/table>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/products.html b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/products.html
new file mode 100644
index 0000000..e4780b9
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/products.html
@@ -0,0 +1,33 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>View Source Code</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="products.jsp"><img src="../../images/execute.gif" align="right" border="0"></a>
+<a href="../../index.html"><img src="../../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="products.jsp.html">Source Code for products.jsp<font color="#0000FF"></a>
+  </font> </h3>
+<h3><a href="displayProducts.tag.html">Source Code for displayProducts.tag<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/products.jsp b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/products.jsp
new file mode 100644
index 0000000..328cc96
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/products.jsp
@@ -0,0 +1,54 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib prefix="tags" tagdir="/WEB-INF/tags" %>
+<html>
+  <head>
+    <title>JSP 2.0 Examples - Display Products Tag File</title>
+  </head>
+  <body>
+    <h1>JSP 2.0 Examples - Display Products Tag File</h1>
+    <hr>
+    <p>This JSP page invokes a tag file that displays a listing of 
+    products.  The custom tag accepts two fragments that enable
+    customization of appearance.  One for when the product is on sale
+    and one for normal price.</p>
+    <p>The tag is invoked twice, using different styles</p>
+    <hr>
+    <h2>Products</h2>
+    <tags:displayProducts>
+      <jsp:attribute name="normalPrice">
+	Item: ${name}<br/>
+	Price: ${price}
+      </jsp:attribute>
+      <jsp:attribute name="onSale">
+	Item: ${name}<br/>
+	<font color="red"><strike>Was: ${origPrice}</strike></font><br/>
+	<b>Now: ${salePrice}</b>
+      </jsp:attribute>
+    </tags:displayProducts>
+    <hr>
+    <h2>Products (Same tag, alternate style)</h2>
+    <tags:displayProducts>
+      <jsp:attribute name="normalPrice">
+	<b>${name}</b> @ ${price} ea.
+      </jsp:attribute>
+      <jsp:attribute name="onSale">
+	<b>${name}</b> @ ${salePrice} ea. (was: ${origPrice})
+      </jsp:attribute>
+    </tags:displayProducts>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/products.jsp.html b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/products.jsp.html
new file mode 100644
index 0000000..f9b6e6f
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/products.jsp.html
@@ -0,0 +1,56 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib prefix="tags" tagdir="/WEB-INF/tags" %>
+&lt;html>
+  &lt;head>
+    &lt;title>JSP 2.0 Examples - Display Products Tag File&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>JSP 2.0 Examples - Display Products Tag File&lt;/h1>
+    &lt;hr>
+    &lt;p>This JSP page invokes a tag file that displays a listing of 
+    products.  The custom tag accepts two fragments that enable
+    customization of appearance.  One for when the product is on sale
+    and one for normal price.&lt;/p>
+    &lt;p>The tag is invoked twice, using different styles&lt;/p>
+    &lt;hr>
+    &lt;h2>Products&lt;/h2>
+    &lt;tags:displayProducts>
+      &lt;jsp:attribute name="normalPrice">
+	Item: ${name}&lt;br/>
+	Price: ${price}
+      &lt;/jsp:attribute>
+      &lt;jsp:attribute name="onSale">
+	Item: ${name}&lt;br/>
+	&lt;font color="red">&lt;strike>Was: ${origPrice}&lt;/strike>&lt;/font>&lt;br/>
+	&lt;b>Now: ${salePrice}&lt;/b>
+      &lt;/jsp:attribute>
+    &lt;/tags:displayProducts>
+    &lt;hr>
+    &lt;h2>Products (Same tag, alternate style)&lt;/h2>
+    &lt;tags:displayProducts>
+      &lt;jsp:attribute name="normalPrice">
+	&lt;b>${name}&lt;/b> @ ${price} ea.
+      &lt;/jsp:attribute>
+      &lt;jsp:attribute name="onSale">
+	&lt;b>${name}&lt;/b> @ ${salePrice} ea. (was: ${origPrice})
+      &lt;/jsp:attribute>
+    &lt;/tags:displayProducts>
+  &lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/xhtmlbasic.tag.html b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/xhtmlbasic.tag.html
new file mode 100644
index 0000000..a8bd497
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsp2/tagfiles/xhtmlbasic.tag.html
@@ -0,0 +1,23 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.0//EN"
+"http://www.w3.org/TR/xhtml-basic/xhtml-basic10.dtd">
+&lt;html xmlns="http://www.w3.org/1999/xhtml">
+&lt;jsp:doBody/>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsptoserv/hello.jsp b/tomcat-uid/webapps/examples/jsp/jsptoserv/hello.jsp
new file mode 100644
index 0000000..5f332ec
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsptoserv/hello.jsp
@@ -0,0 +1,26 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<body bgcolor="white">
+
+<h1>
+I have been invoked by
+<% out.print (request.getAttribute("servletName").toString()); %>
+Servlet.
+</h1>
+
+</html>
\ No newline at end of file
diff --git a/tomcat-uid/webapps/examples/jsp/jsptoserv/hello.jsp.html b/tomcat-uid/webapps/examples/jsp/jsptoserv/hello.jsp.html
new file mode 100644
index 0000000..44ac35e
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsptoserv/hello.jsp.html
@@ -0,0 +1,28 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;body bgcolor="white">
+
+&lt;h1>
+I have been invoked by
+&lt;% out.print (request.getAttribute("servletName").toString()); %>
+Servlet.
+&lt;/h1>
+
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsptoserv/jsptoservlet.jsp b/tomcat-uid/webapps/examples/jsp/jsptoserv/jsptoservlet.jsp
new file mode 100644
index 0000000..c08192f
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsptoserv/jsptoservlet.jsp
@@ -0,0 +1,23 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<body bgcolor="white">
+
+<!-- Forward to a servlet -->
+<jsp:forward page="/servletToJsp" />
+
+</html>
\ No newline at end of file
diff --git a/tomcat-uid/webapps/examples/jsp/jsptoserv/jsptoservlet.jsp.html b/tomcat-uid/webapps/examples/jsp/jsptoserv/jsptoservlet.jsp.html
new file mode 100644
index 0000000..d694ab4
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsptoserv/jsptoservlet.jsp.html
@@ -0,0 +1,25 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;body bgcolor="white">
+
+&lt;!-- Forward to a servlet -->
+&lt;jsp:forward page="/servletToJsp" />
+
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsptoserv/jts.html b/tomcat-uid/webapps/examples/jsp/jsptoserv/jts.html
new file mode 100644
index 0000000..ec7d5ad
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsptoserv/jts.html
@@ -0,0 +1,34 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="jsptoservlet.jsp"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="jsptoservlet.jsp.html">Source Code for JSP calling servlet <font color="#0000FF"></a>
+  </font> </h3>
+
+<h3><a href="servletToJsp.java.html">Source Code for Servlet calling JSP 
+<font color="#0000FF"></a> </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/jsptoserv/servletToJsp.java.html b/tomcat-uid/webapps/examples/jsp/jsptoserv/servletToJsp.java.html
new file mode 100644
index 0000000..bf6f249
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/jsptoserv/servletToJsp.java.html
@@ -0,0 +1,34 @@
+<html><body><pre>
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+import javax.servlet.http.*;
+
+public class servletToJsp extends HttpServlet {
+
+    public void doGet (HttpServletRequest request,
+		       HttpServletResponse response) {
+
+	try {
+	    // Set the attribute and Forward to hello.jsp
+	    request.setAttribute ("servletName", "servletToJsp");
+	    getServletConfig().getServletContext().getRequestDispatcher("/jsp/jsptoserv/hello.jsp").forward(request, response);
+	} catch (Exception ex) {
+	    ex.printStackTrace ();
+	}
+    }
+}
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/num/numguess.html b/tomcat-uid/webapps/examples/jsp/num/numguess.html
new file mode 100644
index 0000000..431fda0
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/num/numguess.html
@@ -0,0 +1,34 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  Number Guess Game
+  Written by Jason Hunter, CTO, K&A Software
+  http://www.servlets.com
+-->
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="numguess.jsp"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="numguess.jsp.html">Source Code for Numguess Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/num/numguess.jsp b/tomcat-uid/webapps/examples/jsp/num/numguess.jsp
new file mode 100644
index 0000000..cfcf6fb
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/num/numguess.jsp
@@ -0,0 +1,69 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  Number Guess Game
+  Written by Jason Hunter, CTO, K&A Software
+  http://www.servlets.com
+-->
+
+<%@ page import = "num.NumberGuessBean" %>
+
+<jsp:useBean id="numguess" class="num.NumberGuessBean" scope="session"/>
+<jsp:setProperty name="numguess" property="*"/>
+
+<html>
+<head><title>Number Guess</title></head>
+<body bgcolor="white">
+<font size=4>
+
+<% if (numguess.getSuccess()) { %>
+
+  Congratulations!  You got it.
+  And after just <%= numguess.getNumGuesses() %> tries.<p>
+
+  <% numguess.reset(); %>
+
+  Care to <a href="numguess.jsp">try again</a>?
+
+<% } else if (numguess.getNumGuesses() == 0) { %>
+
+  Welcome to the Number Guess game.<p>
+
+  I'm thinking of a number between 1 and 100.<p>
+
+  <form method=get>
+  What's your guess? <input type=text name=guess>
+  <input type=submit value="Submit">
+  </form>
+
+<% } else { %>
+
+  Good guess, but nope.  Try <b><%= numguess.getHint() %></b>.
+
+  You have made <%= numguess.getNumGuesses() %> guesses.<p>
+
+  I'm thinking of a number between 1 and 100.<p>
+
+  <form method=get>
+  What's your guess? <input type=text name=guess>
+  <input type=submit value="Submit">
+  </form>
+
+<% } %>
+
+</font>
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/num/numguess.jsp.html b/tomcat-uid/webapps/examples/jsp/num/numguess.jsp.html
new file mode 100644
index 0000000..01fef5d
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/num/numguess.jsp.html
@@ -0,0 +1,71 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  Number Guess Game
+  Written by Jason Hunter, CTO, K&amp;A Software
+  http://www.servlets.com
+-->
+
+&lt;%@ page import = "num.NumberGuessBean" %>
+
+&lt;jsp:useBean id="numguess" class="num.NumberGuessBean" scope="session"/>
+&lt;jsp:setProperty name="numguess" property="*"/>
+
+&lt;html>
+&lt;head>&lt;title>Number Guess&lt;/title>&lt;/head>
+&lt;body bgcolor="white">
+&lt;font size=4>
+
+&lt;% if (numguess.getSuccess()) { %>
+
+  Congratulations!  You got it.
+  And after just &lt;%= numguess.getNumGuesses() %> tries.&lt;p>
+
+  &lt;% numguess.reset(); %>
+
+  Care to &lt;a href="numguess.jsp">try again&lt;/a>?
+
+&lt;% } else if (numguess.getNumGuesses() == 0) { %>
+
+  Welcome to the Number Guess game.&lt;p>
+
+  I'm thinking of a number between 1 and 100.&lt;p>
+
+  &lt;form method=get>
+  What's your guess? &lt;input type=text name=guess>
+  &lt;input type=submit value="Submit">
+  &lt;/form>
+
+&lt;% } else { %>
+
+  Good guess, but nope.  Try &lt;b>&lt;%= numguess.getHint() %>&lt;/b>.
+
+  You have made &lt;%= numguess.getNumGuesses() %> guesses.&lt;p>
+
+  I'm thinking of a number between 1 and 100.&lt;p>
+
+  &lt;form method=get>
+  What's your guess? &lt;input type=text name=guess>
+  &lt;input type=submit value="Submit">
+  &lt;/form>
+
+&lt;% } %>
+
+&lt;/font>
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/plugin/applet/Clock2.class b/tomcat-uid/webapps/examples/jsp/plugin/applet/Clock2.class
new file mode 100644
index 0000000..32fa663
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/plugin/applet/Clock2.class
Binary files differ
diff --git a/tomcat-uid/webapps/examples/jsp/plugin/applet/Clock2.java b/tomcat-uid/webapps/examples/jsp/plugin/applet/Clock2.java
new file mode 100644
index 0000000..f228b82
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/plugin/applet/Clock2.java
@@ -0,0 +1,213 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import java.util.*;
+import java.awt.*;
+import java.applet.*;
+import java.text.*;
+
+/**
+ * Time!
+ *
+ * @author Rachel Gollub
+ */
+
+public class Clock2 extends Applet implements Runnable {
+    Thread timer;                // The thread that displays clock
+    int lastxs, lastys, lastxm,
+        lastym, lastxh, lastyh;  // Dimensions used to draw hands 
+    SimpleDateFormat formatter;  // Formats the date displayed
+    String lastdate;             // String to hold date displayed
+    Font clockFaceFont;          // Font for number display on clock
+    Date currentDate;            // Used to get date to display
+    Color handColor;             // Color of main hands and dial
+    Color numberColor;           // Color of second hand and numbers
+
+    public void init() {
+        int x,y;
+        lastxs = lastys = lastxm = lastym = lastxh = lastyh = 0;
+        formatter = new SimpleDateFormat ("EEE MMM dd hh:mm:ss yyyy", Locale.getDefault());
+        currentDate = new Date();
+        lastdate = formatter.format(currentDate);
+        clockFaceFont = new Font("Serif", Font.PLAIN, 14);
+        handColor = Color.blue;
+        numberColor = Color.darkGray;
+
+        try {
+            setBackground(new Color(Integer.parseInt(getParameter("bgcolor"),16)));
+        } catch (Exception E) { }
+        try {
+            handColor = new Color(Integer.parseInt(getParameter("fgcolor1"),16));
+        } catch (Exception E) { }
+        try {
+            numberColor = new Color(Integer.parseInt(getParameter("fgcolor2"),16));
+        } catch (Exception E) { }
+        resize(300,300);              // Set clock window size
+    }
+
+    // Plotpoints allows calculation to only cover 45 degrees of the circle,
+    // and then mirror
+    public void plotpoints(int x0, int y0, int x, int y, Graphics g) {
+        g.drawLine(x0+x,y0+y,x0+x,y0+y);
+        g.drawLine(x0+y,y0+x,x0+y,y0+x);
+        g.drawLine(x0+y,y0-x,x0+y,y0-x);
+        g.drawLine(x0+x,y0-y,x0+x,y0-y);
+        g.drawLine(x0-x,y0-y,x0-x,y0-y);
+        g.drawLine(x0-y,y0-x,x0-y,y0-x);
+        g.drawLine(x0-y,y0+x,x0-y,y0+x);
+        g.drawLine(x0-x,y0+y,x0-x,y0+y);
+    }
+
+    // Circle is just Bresenham's algorithm for a scan converted circle
+    public void circle(int x0, int y0, int r, Graphics g) {
+        int x,y;
+        float d;
+        x=0;
+        y=r;
+        d=5/4-r;
+        plotpoints(x0,y0,x,y,g);
+
+        while (y>x){
+            if (d<0) {
+                d=d+2*x+3;
+                x++;
+            }
+            else {
+                d=d+2*(x-y)+5;
+                x++;
+                y--;
+            }
+            plotpoints(x0,y0,x,y,g);
+        }
+    }
+
+    // Paint is the main part of the program
+    public void paint(Graphics g) {
+        int xh, yh, xm, ym, xs, ys, s = 0, m = 10, h = 10, xcenter, ycenter;
+        String today;
+
+        currentDate = new Date();
+        SimpleDateFormat formatter = new SimpleDateFormat("s",Locale.getDefault());
+        try {
+            s = Integer.parseInt(formatter.format(currentDate));
+        } catch (NumberFormatException n) {
+            s = 0;
+        }
+        formatter.applyPattern("m");
+        try {
+            m = Integer.parseInt(formatter.format(currentDate));
+        } catch (NumberFormatException n) {
+            m = 10;
+        }    
+        formatter.applyPattern("h");
+        try {
+            h = Integer.parseInt(formatter.format(currentDate));
+        } catch (NumberFormatException n) {
+            h = 10;
+        }
+        formatter.applyPattern("EEE MMM dd HH:mm:ss yyyy");
+        today = formatter.format(currentDate);
+        xcenter=80;
+        ycenter=55;
+    
+    // a= s* pi/2 - pi/2 (to switch 0,0 from 3:00 to 12:00)
+    // x = r(cos a) + xcenter, y = r(sin a) + ycenter
+    
+        xs = (int)(Math.cos(s * 3.14f/30 - 3.14f/2) * 45 + xcenter);
+        ys = (int)(Math.sin(s * 3.14f/30 - 3.14f/2) * 45 + ycenter);
+        xm = (int)(Math.cos(m * 3.14f/30 - 3.14f/2) * 40 + xcenter);
+        ym = (int)(Math.sin(m * 3.14f/30 - 3.14f/2) * 40 + ycenter);
+        xh = (int)(Math.cos((h*30 + m/2) * 3.14f/180 - 3.14f/2) * 30 + xcenter);
+        yh = (int)(Math.sin((h*30 + m/2) * 3.14f/180 - 3.14f/2) * 30 + ycenter);
+    
+    // Draw the circle and numbers
+    
+        g.setFont(clockFaceFont);
+        g.setColor(handColor);
+        circle(xcenter,ycenter,50,g);
+        g.setColor(numberColor);
+        g.drawString("9",xcenter-45,ycenter+3); 
+        g.drawString("3",xcenter+40,ycenter+3);
+        g.drawString("12",xcenter-5,ycenter-37);
+        g.drawString("6",xcenter-3,ycenter+45);
+
+    // Erase if necessary, and redraw
+    
+        g.setColor(getBackground());
+        if (xs != lastxs || ys != lastys) {
+            g.drawLine(xcenter, ycenter, lastxs, lastys);
+            g.drawString(lastdate, 5, 125);
+        }
+        if (xm != lastxm || ym != lastym) {
+            g.drawLine(xcenter, ycenter-1, lastxm, lastym);
+            g.drawLine(xcenter-1, ycenter, lastxm, lastym); }
+        if (xh != lastxh || yh != lastyh) {
+            g.drawLine(xcenter, ycenter-1, lastxh, lastyh);
+            g.drawLine(xcenter-1, ycenter, lastxh, lastyh); }
+        g.setColor(numberColor);
+        g.drawString("", 5, 125);
+        g.drawString(today, 5, 125);    
+        g.drawLine(xcenter, ycenter, xs, ys);
+        g.setColor(handColor);
+        g.drawLine(xcenter, ycenter-1, xm, ym);
+        g.drawLine(xcenter-1, ycenter, xm, ym);
+        g.drawLine(xcenter, ycenter-1, xh, yh);
+        g.drawLine(xcenter-1, ycenter, xh, yh);
+        lastxs=xs; lastys=ys;
+        lastxm=xm; lastym=ym;
+        lastxh=xh; lastyh=yh;
+        lastdate = today;
+        currentDate=null;
+    }
+
+    public void start() {
+        timer = new Thread(this);
+        timer.start();
+    }
+
+    public void stop() {
+        timer = null;
+    }
+
+    public void run() {
+        Thread me = Thread.currentThread();
+        while (timer == me) {
+            try {
+                Thread.currentThread().sleep(100);
+            } catch (InterruptedException e) {
+            }
+            repaint();
+        }
+    }
+
+    public void update(Graphics g) {
+        paint(g);
+    }
+
+    public String getAppletInfo() {
+        return "Title: A Clock \nAuthor: Rachel Gollub, 1995 \nAn analog clock.";
+    }
+  
+    public String[][] getParameterInfo() {
+        String[][] info = {
+            {"bgcolor", "hexadecimal RGB number", "The background color. Default is the color of your browser."},
+            {"fgcolor1", "hexadecimal RGB number", "The color of the hands and dial. Default is blue."},
+            {"fgcolor2", "hexadecimal RGB number", "The color of the seconds hand and numbers. Default is dark gray."}
+        };
+        return info;
+    }
+}
diff --git a/tomcat-uid/webapps/examples/jsp/plugin/plugin.html b/tomcat-uid/webapps/examples/jsp/plugin/plugin.html
new file mode 100644
index 0000000..036ce72
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/plugin/plugin.html
@@ -0,0 +1,30 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="plugin.jsp"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="plugin.jsp.html">Source Code for Plugin Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/plugin/plugin.jsp b/tomcat-uid/webapps/examples/jsp/plugin/plugin.jsp
new file mode 100644
index 0000000..12db7d4
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/plugin/plugin.jsp
@@ -0,0 +1,34 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<title> Plugin example </title>
+<body bgcolor="white">
+<h3> Current time is : </h3>
+<jsp:plugin type="applet" code="Clock2.class" codebase="applet" jreversion="1.2" width="160" height="150" >
+    <jsp:fallback>
+        Plugin tag OBJECT or EMBED not supported by browser.
+    </jsp:fallback>
+</jsp:plugin>
+<p>
+<h4>
+<font color=red> 
+The above applet is loaded using the Java Plugin from a jsp page using the
+plugin tag.
+</font>
+</h4>
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/plugin/plugin.jsp.html b/tomcat-uid/webapps/examples/jsp/plugin/plugin.jsp.html
new file mode 100644
index 0000000..b350d5e
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/plugin/plugin.jsp.html
@@ -0,0 +1,36 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;title> Plugin example &lt;/title>
+&lt;body bgcolor="white">
+&lt;h3> Current time is : &lt;/h3>
+&lt;jsp:plugin type="applet" code="Clock2.class" codebase="applet" jreversion="1.2" width="160" height="150" >
+    &lt;jsp:fallback>
+        Plugin tag OBJECT or EMBED not supported by browser.
+    &lt;/jsp:fallback>
+&lt;/jsp:plugin>
+&lt;p>
+&lt;h4>
+&lt;font color=red> 
+The above applet is loaded using the Java Plugin from a jsp page using the
+plugin tag.
+&lt;/font>
+&lt;/h4>
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/security/protected/error.jsp b/tomcat-uid/webapps/examples/jsp/security/protected/error.jsp
new file mode 100644
index 0000000..50e0ed5
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/security/protected/error.jsp
@@ -0,0 +1,25 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+<head>
+<title>Error Page For Examples</title>
+</head>
+<body bgcolor="white">
+Invalid username and/or password, please try
+<a href='<%= response.encodeURL("index.jsp") %>'>again</a>.
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/security/protected/error.jsp.html b/tomcat-uid/webapps/examples/jsp/security/protected/error.jsp.html
new file mode 100644
index 0000000..d45fb6c
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/security/protected/error.jsp.html
@@ -0,0 +1,27 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;html>
+&lt;head>
+&lt;title>Error Page For Examples&lt;/title>
+&lt;/head>
+&lt;body bgcolor="white">
+Invalid username and/or password, please try
+&lt;a href='&lt;%= response.encodeURL("index.jsp") %>'>again&lt;/a>.
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/security/protected/index.jsp b/tomcat-uid/webapps/examples/jsp/security/protected/index.jsp
new file mode 100644
index 0000000..bef9700
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/security/protected/index.jsp
@@ -0,0 +1,81 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%
+  if (request.getParameter("logoff") != null) {
+    session.invalidate();
+    response.sendRedirect("index.jsp");
+    return;
+  }
+%>
+<html>
+<head>
+<title>Protected Page for Examples</title>
+</head>
+<body bgcolor="white">
+
+You are logged in as remote user
+<b><%= util.HTMLFilter.filter(request.getRemoteUser()) %></b>
+in session <b><%= session.getId() %></b><br><br>
+
+<%
+  if (request.getUserPrincipal() != null) {
+%>
+    Your user principal name is
+    <b><%= util.HTMLFilter.filter(request.getUserPrincipal().getName()) %></b>
+    <br><br>
+<%
+  } else {
+%>
+    No user principal could be identified.<br><br>
+<%
+  }
+%>
+
+<%
+  String role = request.getParameter("role");
+  if (role == null)
+    role = "";
+  if (role.length() > 0) {
+    if (request.isUserInRole(role)) {
+%>
+      You have been granted role
+      <b><%= util.HTMLFilter.filter(role) %></b><br><br>
+<%
+    } else {
+%>
+      You have <i>not</i> been granted role
+      <b><%= util.HTMLFilter.filter(role) %></b><br><br>
+<%
+    }
+  }
+%>
+
+To check whether your username has been granted a particular role,
+enter it here:
+<form method="GET" action='<%= response.encodeURL("index.jsp") %>'>
+<input type="text" name="role" value="<%= util.HTMLFilter.filter(role) %>">
+</form>
+<br><br>
+
+If you have configured this app for form-based authentication, you can log
+off by clicking
+<a href='<%= response.encodeURL("index.jsp?logoff=true") %>'>here</a>.
+This should cause you to be returned to the logon page after the redirect
+that is performed.
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/security/protected/index.jsp.html b/tomcat-uid/webapps/examples/jsp/security/protected/index.jsp.html
new file mode 100644
index 0000000..b8a9a54
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/security/protected/index.jsp.html
@@ -0,0 +1,83 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%
+  if (request.getParameter("logoff") != null) {
+    session.invalidate();
+    response.sendRedirect("index.jsp");
+    return;
+  }
+%>
+&lt;html>
+&lt;head>
+&lt;title>Protected Page for Examples&lt;/title>
+&lt;/head>
+&lt;body bgcolor="white">
+
+You are logged in as remote user
+&lt;b>&lt;%= util.HTMLFilter.filter(request.getRemoteUser()) %>&lt;/b>
+in session &lt;b>&lt;%= session.getId() %>&lt;/b>&lt;br>&lt;br>
+
+&lt;%
+  if (request.getUserPrincipal() != null) {
+%>
+    Your user principal name is
+    &lt;b>&lt;%= util.HTMLFilter.filter(request.getUserPrincipal().getName()) %>&lt;/b>
+    &lt;br>&lt;br>
+&lt;%
+  } else {
+%>
+    No user principal could be identified.&lt;br>&lt;br>
+&lt;%
+  }
+%>
+
+&lt;%
+  String role = request.getParameter("role");
+  if (role == null)
+    role = "";
+  if (role.length() > 0) {
+    if (request.isUserInRole(role)) {
+%>
+      You have been granted role
+      &lt;b>&lt;%= util.HTMLFilter.filter(role) %>&lt;/b>&lt;br>&lt;br>
+&lt;%
+    } else {
+%>
+      You have &lt;i>not&lt;/i> been granted role
+      &lt;b>&lt;%= util.HTMLFilter.filter(role) %>&lt;/b>&lt;br>&lt;br>
+&lt;%
+    }
+  }
+%>
+
+To check whether your username has been granted a particular role,
+enter it here:
+&lt;form method="GET" action='&lt;%= response.encodeURL("index.jsp") %>'>
+&lt;input type="text" name="role" value="&lt;%= util.HTMLFilter.filter(role) %>">
+&lt;/form>
+&lt;br>&lt;br>
+
+If you have configured this app for form-based authentication, you can log
+off by clicking
+&lt;a href='&lt;%= response.encodeURL("index.jsp?logoff=true") %>'>here&lt;/a>.
+This should cause you to be returned to the logon page after the redirect
+that is performed.
+
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/security/protected/login.jsp b/tomcat-uid/webapps/examples/jsp/security/protected/login.jsp
new file mode 100644
index 0000000..dc7e50e
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/security/protected/login.jsp
@@ -0,0 +1,38 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+<head>
+<title>Login Page for Examples</title>
+<body bgcolor="white">
+<form method="POST" action='<%= response.encodeURL("j_security_check") %>' >
+  <table border="0" cellspacing="5">
+    <tr>
+      <th align="right">Username:</th>
+      <td align="left"><input type="text" name="j_username"></td>
+    </tr>
+    <tr>
+      <th align="right">Password:</th>
+      <td align="left"><input type="password" name="j_password"></td>
+    </tr>
+    <tr>
+      <td align="right"><input type="submit" value="Log In"></td>
+      <td align="left"><input type="reset"></td>
+    </tr>
+  </table>
+</form>
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/security/protected/login.jsp.html b/tomcat-uid/webapps/examples/jsp/security/protected/login.jsp.html
new file mode 100644
index 0000000..94e16ef
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/security/protected/login.jsp.html
@@ -0,0 +1,40 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;html>
+&lt;head>
+&lt;title>Login Page for Examples&lt;/title>
+&lt;body bgcolor="white">
+&lt;form method="POST" action='&lt;%= response.encodeURL("j_security_check") %>' >
+  &lt;table border="0" cellspacing="5">
+    &lt;tr>
+      &lt;th align="right">Username:&lt;/th>
+      &lt;td align="left">&lt;input type="text" name="j_username">&lt;/td>
+    &lt;/tr>
+    &lt;tr>
+      &lt;th align="right">Password:&lt;/th>
+      &lt;td align="left">&lt;input type="password" name="j_password">&lt;/td>
+    &lt;/tr>
+    &lt;tr>
+      &lt;td align="right">&lt;input type="submit" value="Log In">&lt;/td>
+      &lt;td align="left">&lt;input type="reset">&lt;/td>
+    &lt;/tr>
+  &lt;/table>
+&lt;/form>
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/sessions/DummyCart.html b/tomcat-uid/webapps/examples/jsp/sessions/DummyCart.html
new file mode 100644
index 0000000..317523f
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/sessions/DummyCart.html
@@ -0,0 +1,56 @@
+<HTML>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<HEAD>
+<title>
+sessions.DummyCart Bean Properties
+</title>
+<BODY BGCOLOR="white">
+<H2>
+sessions.DummyCart Bean Properties
+</H2>
+<HR>
+<DL>
+<DT>public class <B>DummyCart</B><DT>extends Object</DL>
+
+<P>
+<HR>
+
+<P>
+
+<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0">
+<TR BGCOLOR="#EEEEFF">
+<TD COLSPAN=3><FONT SIZE="+2">
+<B>Properties Summary</B></FONT></TD>
+</TR>
+<TR BGCOLOR="white">
+<td align="right" valign="top" width="1%">
+<FONT SIZE="-1">
+String
+</FONT></TD>
+<TD><B>DummyCart:items</B>
+<BR>
+       </TD>
+<td width="1%">
+<FONT SIZE="-1">
+Multi
+</FONT></TD>
+</TABLE>
+<HR>
+</BODY>
+</HTML>
diff --git a/tomcat-uid/webapps/examples/jsp/sessions/carts.html b/tomcat-uid/webapps/examples/jsp/sessions/carts.html
new file mode 100644
index 0000000..fe7dbb5
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/sessions/carts.html
@@ -0,0 +1,53 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+    <title>carts</title>
+</head>
+
+ <body bgcolor="white">
+<font size = 5 color="#CC0000">
+
+<form type=POST action=carts.jsp>
+<BR>
+Please enter item to add or remove:
+<br>
+Add Item:
+
+<SELECT NAME="item">
+<OPTION>Beavis & Butt-head Video collection
+<OPTION>X-files movie
+<OPTION>Twin peaks tapes
+<OPTION>NIN CD
+<OPTION>JSP Book
+<OPTION>Concert tickets
+<OPTION>Love life
+<OPTION>Switch blade
+<OPTION>Rex, Rugs & Rock n' Roll
+</SELECT>
+
+
+<br> <br>
+<INPUT TYPE=submit name="submit" value="add">
+<INPUT TYPE=submit name="submit" value="remove">
+
+</form>
+       
+</FONT>
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/sessions/carts.jsp b/tomcat-uid/webapps/examples/jsp/sessions/carts.jsp
new file mode 100644
index 0000000..e84170a
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/sessions/carts.jsp
@@ -0,0 +1,44 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<jsp:useBean id="cart" scope="session" class="sessions.DummyCart" />
+
+<jsp:setProperty name="cart" property="*" />
+<%
+	cart.processRequest();
+%>
+
+
+<FONT size = 5 COLOR="#CC0000">
+<br> You have the following items in your cart:
+<ol>
+<% 
+	String[] items = cart.getItems();
+	for (int i=0; i<items.length; i++) {
+%>
+<li> <% out.print(util.HTMLFilter.filter(items[i])); %> 
+<%
+	}
+%>
+</ol>
+
+</FONT>
+
+<hr>
+<%@ include file ="carts.html" %>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/sessions/carts.jsp.html b/tomcat-uid/webapps/examples/jsp/sessions/carts.jsp.html
new file mode 100644
index 0000000..92d40c9
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/sessions/carts.jsp.html
@@ -0,0 +1,46 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;jsp:useBean id="cart" scope="session" class="sessions.DummyCart" />
+
+&lt;jsp:setProperty name="cart" property="*" />
+&lt;%
+	cart.processRequest();
+%>
+
+
+&lt;FONT size = 5 COLOR="#CC0000">
+&lt;br> You have the following items in your cart:
+&lt;ol>
+&lt;% 
+	String[] items = cart.getItems();
+	for (int i=0; i&lt;items.length; i++) {
+%>
+&lt;li> &lt;% out.print(util.HTMLFilter.filter(items[i])); %> 
+&lt;%
+	}
+%>
+&lt;/ol>
+
+&lt;/FONT>
+
+&lt;hr>
+&lt;%@ include file ="carts.html" %>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/sessions/crt.html b/tomcat-uid/webapps/examples/jsp/sessions/crt.html
new file mode 100644
index 0000000..28804e9
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/sessions/crt.html
@@ -0,0 +1,34 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="carts.html"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="carts.jsp.html">Source Code for Cart Example<font color="#0000FF"></a>
+  </font> </h3>
+
+<h3><a href="DummyCart.html">Property Sheet for DummyCart
+<font color="#0000FF"></a> </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/simpletag/foo.html b/tomcat-uid/webapps/examples/jsp/simpletag/foo.html
new file mode 100644
index 0000000..334b6bc
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/simpletag/foo.html
@@ -0,0 +1,30 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="foo.jsp"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="foo.jsp.html">Source Code for the Simple Tag Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/simpletag/foo.jsp b/tomcat-uid/webapps/examples/jsp/simpletag/foo.jsp
new file mode 100644
index 0000000..19ff087
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/simpletag/foo.jsp
@@ -0,0 +1,38 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<body>
+<%@ taglib uri="http://tomcat.apache.org/examples-taglib" prefix="eg"%>
+
+Radio stations that rock:
+
+<ul>
+<eg:foo att1="98.5" att2="92.3" att3="107.7">
+<li><%= member %></li>
+</eg:foo>
+</ul>
+
+<eg:log>
+Did you see me on the stderr window?
+</eg:log>
+
+<eg:log toBrowser="true">
+Did you see me on the browser window as well?
+</eg:log>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/simpletag/foo.jsp.html b/tomcat-uid/webapps/examples/jsp/simpletag/foo.jsp.html
new file mode 100644
index 0000000..ce7fb97
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/simpletag/foo.jsp.html
@@ -0,0 +1,40 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;body>
+&lt;%@ taglib uri="http://tomcat.apache.org/examples-taglib" prefix="eg"%>
+
+Radio stations that rock:
+
+&lt;ul>
+&lt;eg:foo att1="98.5" att2="92.3" att3="107.7">
+&lt;li>&lt;%= member %>&lt;/li>
+&lt;/eg:foo>
+&lt;/ul>
+
+&lt;eg:log>
+Did you see me on the stderr window?
+&lt;/eg:log>
+
+&lt;eg:log toBrowser="true">
+Did you see me on the browser window as well?
+&lt;/eg:log>
+
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/snp/snoop.html b/tomcat-uid/webapps/examples/jsp/snp/snoop.html
new file mode 100644
index 0000000..c00aca7
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/snp/snoop.html
@@ -0,0 +1,31 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="snoop.jsp"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="snoop.jsp.html">Source Code for Request Parameters Example<font color="#0000FF">
+  </font></a></h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/snp/snoop.jsp b/tomcat-uid/webapps/examples/jsp/snp/snoop.jsp
new file mode 100644
index 0000000..06a3830
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/snp/snoop.jsp
@@ -0,0 +1,57 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<body bgcolor="white">
+<h1> Request Information </h1>
+<font size="4">
+JSP Request Method: <%= util.HTMLFilter.filter(request.getMethod()) %>
+<br>
+Request URI: <%= util.HTMLFilter.filter(request.getRequestURI()) %>
+<br>
+Request Protocol: <%= util.HTMLFilter.filter(request.getProtocol()) %>
+<br>
+Servlet path: <%= util.HTMLFilter.filter(request.getServletPath()) %>
+<br>
+Path info: <%= util.HTMLFilter.filter(request.getPathInfo()) %>
+<br>
+Query string: <%= util.HTMLFilter.filter(request.getQueryString()) %>
+<br>
+Content length: <%= request.getContentLength() %>
+<br>
+Content type: <%= util.HTMLFilter.filter(request.getContentType()) %>
+<br>
+Server name: <%= util.HTMLFilter.filter(request.getServerName()) %>
+<br>
+Server port: <%= request.getServerPort() %>
+<br>
+Remote user: <%= util.HTMLFilter.filter(request.getRemoteUser()) %>
+<br>
+Remote address: <%= util.HTMLFilter.filter(request.getRemoteAddr()) %>
+<br>
+Remote host: <%= util.HTMLFilter.filter(request.getRemoteHost()) %>
+<br>
+Authorization scheme: <%= util.HTMLFilter.filter(request.getAuthType()) %> 
+<br>
+Locale: <%= request.getLocale() %>
+<hr>
+The browser you are using is
+<%= util.HTMLFilter.filter(request.getHeader("User-Agent")) %>
+<hr>
+</font>
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/snp/snoop.jsp.html b/tomcat-uid/webapps/examples/jsp/snp/snoop.jsp.html
new file mode 100644
index 0000000..13025fb
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/snp/snoop.jsp.html
@@ -0,0 +1,59 @@
+<html><body><pre>
+&lt;html>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+&lt;body bgcolor="white">
+&lt;h1> Request Information &lt;/h1>
+&lt;font size="4">
+JSP Request Method: &lt;%= util.HTMLFilter.filter(request.getMethod()) %>
+&lt;br>
+Request URI: &lt;%= util.HTMLFilter.filter(request.getRequestURI()) %>
+&lt;br>
+Request Protocol: &lt;%= util.HTMLFilter.filter(request.getProtocol()) %>
+&lt;br>
+Servlet path: &lt;%= util.HTMLFilter.filter(request.getServletPath()) %>
+&lt;br>
+Path info: &lt;%= util.HTMLFilter.filter(request.getPathInfo()) %>
+&lt;br>
+Query string: &lt;%= util.HTMLFilter.filter(request.getQueryString()) %>
+&lt;br>
+Content length: &lt;%= request.getContentLength() %>
+&lt;br>
+Content type: &lt;%= util.HTMLFilter.filter(request.getContentType()) %>
+&lt;br>
+Server name: &lt;%= util.HTMLFilter.filter(request.getServerName()) %>
+&lt;br>
+Server port: &lt;%= request.getServerPort() %>
+&lt;br>
+Remote user: &lt;%= util.HTMLFilter.filter(request.getRemoteUser()) %>
+&lt;br>
+Remote address: &lt;%= util.HTMLFilter.filter(request.getRemoteAddr()) %>
+&lt;br>
+Remote host: &lt;%= util.HTMLFilter.filter(request.getRemoteHost()) %>
+&lt;br>
+Authorization scheme: &lt;%= util.HTMLFilter.filter(request.getAuthType()) %> 
+&lt;br>
+Locale: &lt;%= request.getLocale() %>
+&lt;hr>
+The browser you are using is
+&lt;%= util.HTMLFilter.filter(request.getHeader("User-Agent")) %>
+&lt;hr>
+&lt;/font>
+&lt;/body>
+&lt;/html>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/source.jsp b/tomcat-uid/webapps/examples/jsp/source.jsp
new file mode 100644
index 0000000..efa329a
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/source.jsp
@@ -0,0 +1,20 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<%@ taglib uri="http://tomcat.apache.org/examples-taglib"
+        prefix="eg" %>
+
+<eg:ShowSource jspFile="<%= util.HTMLFilter.filter(request.getQueryString()) %>"/>
diff --git a/tomcat-uid/webapps/examples/jsp/source.jsp.html b/tomcat-uid/webapps/examples/jsp/source.jsp.html
new file mode 100644
index 0000000..841dd3f
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/source.jsp.html
@@ -0,0 +1,22 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;%@ taglib uri="http://tomcat.apache.org/examples-taglib"
+        prefix="eg" %>
+
+&lt;eg:ShowSource jspFile="&lt;%= util.HTMLFilter.filter(request.getQueryString()) %>"/>
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/choose.html b/tomcat-uid/webapps/examples/jsp/tagplugin/choose.html
new file mode 100644
index 0000000..fdec617
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/choose.html
@@ -0,0 +1,36 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+<head>
+<title>View Source Code</title>
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF">
+  <a href="choose.jsp">
+    <img src="../images/execute.gif" align="right" border="0"></a>
+  <a href="../index.html">
+    <img src="../images/return.gif" width="24" height="24" align="right" border="0">
+  </a></font>
+</p>
+
+<h3>
+  <a href="choose.jsp.html">Source Code for choose.jsp<font color="#0000FF"/></a>
+</h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/choose.jsp b/tomcat-uid/webapps/examples/jsp/tagplugin/choose.jsp
new file mode 100644
index 0000000..2427249
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/choose.jsp
@@ -0,0 +1,58 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+  <head>
+    <title>Tag Examples - choose</title>
+  </head>
+  <body>
+    <h1>Tag Plugin Examples - &lt;c:choose></h1>
+
+    <hr>
+    </br>
+    <a href="notes.html">Plugin Introductory Notes<font <font color="#0000FF"></
+a>
+    <br/>
+    <a href="howto.html">Brief Instructions for Writing Plugins<font color="#000
+0
+FF"></a>
+    <br/> <br/>
+    <hr>
+
+    <font color="#000000"/>
+    </br>
+
+    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
+
+    <c:forEach var="index" begin="0" end="4">
+      # ${index}: 
+      <c:choose>
+	<c:when test="${index == 1}">
+          One!</br>
+	</c:when>
+	<c:when test="${index == 4}">
+          Four!</br>
+	</c:when>
+	<c:when test="${index == 3}">
+          Three!</br>
+	</c:when>
+	<c:otherwise>
+          Huh?</br>
+	</c:otherwise>
+      </c:choose>
+    </c:forEach>
+  </body>
+</html> 
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/choose.jsp.html b/tomcat-uid/webapps/examples/jsp/tagplugin/choose.jsp.html
new file mode 100644
index 0000000..d95ab00
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/choose.jsp.html
@@ -0,0 +1,60 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;html>
+  &lt;head>
+    &lt;title>Tag Examples - choose&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>Tag Plugin Examples - &amp;lt;c:choose>&lt;/h1>
+
+    &lt;hr>
+    &lt;/br>
+    &lt;a href="notes.html">Plugin Introductory Notes&lt;font &lt;font color="#0000FF">&lt;/
+a>
+    &lt;br/>
+    &lt;a href="howto.html">Brief Instructions for Writing Plugins&lt;font color="#000
+0
+FF">&lt;/a>
+    &lt;br/> &lt;br/>
+    &lt;hr>
+
+    &lt;font color="#000000"/>
+    &lt;/br>
+
+    &lt;%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
+
+    &lt;c:forEach var="index" begin="0" end="4">
+      # ${index}: 
+      &lt;c:choose>
+	&lt;c:when test="${index == 1}">
+          One!&lt;/br>
+	&lt;/c:when>
+	&lt;c:when test="${index == 4}">
+          Four!&lt;/br>
+	&lt;/c:when>
+	&lt;c:when test="${index == 3}">
+          Three!&lt;/br>
+	&lt;/c:when>
+	&lt;c:otherwise>
+          Huh?&lt;/br>
+	&lt;/c:otherwise>
+      &lt;/c:choose>
+    &lt;/c:forEach>
+  &lt;/body>
+&lt;/html> 
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/foreach.html b/tomcat-uid/webapps/examples/jsp/tagplugin/foreach.html
new file mode 100644
index 0000000..f1a9c1d
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/foreach.html
@@ -0,0 +1,36 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+<head>
+<title>View Source Code</title>
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF">
+  <a href="foreach.jsp">
+    <img src="../images/execute.gif" align="right" border="0"></a>
+  <a href="../index.html">
+    <img src="../images/return.gif" width="24" height="24" align="right" border="0">
+  </a></font>
+</p>
+
+<h3>
+  <a href="foreach.jsp.html">Source Code for foreach.jsp<font color="#0000FF"/></a>
+</h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/foreach.jsp b/tomcat-uid/webapps/examples/jsp/tagplugin/foreach.jsp
new file mode 100644
index 0000000..135d5ed
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/foreach.jsp
@@ -0,0 +1,57 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+  <head>
+    <title>Tag Plugin Examples: forEach</title>
+  </head>
+  <body>
+    <h1>Tag Plugin Examples - &lt;c:forEach></h1>
+
+    <hr>
+    </br>
+    <a href="notes.html">Plugin Introductory Notes<font <font color="#0000FF"></
+a>
+    <br/>
+    <a href="howto.html">Brief Instructions for Writing Plugins<font color="#0000
+FF"></a>
+    <br/> <br/>
+    <hr>
+
+    <font color="#000000"/>
+    </br>
+
+    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
+    <%@ page import="java.util.Vector" %>
+
+    <h3>Iterating over a range</h3>
+    <c:forEach var="item" begin="1" end="10">
+        ${item}
+    </c:forEach>
+
+    <% Vector v = new Vector();
+	v.add("One"); v.add("Two"); v.add("Three"); v.add("Four");
+
+	pageContext.setAttribute("vector", v);
+    %>
+
+    <h3>Iterating over a Vector</h3>
+
+    <c:forEach items="${vector}" var="item" >
+	${item}
+    </c:forEach>
+  </body>
+</html> 
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/foreach.jsp.html b/tomcat-uid/webapps/examples/jsp/tagplugin/foreach.jsp.html
new file mode 100644
index 0000000..1d153c1
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/foreach.jsp.html
@@ -0,0 +1,59 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;html>
+  &lt;head>
+    &lt;title>Tag Plugin Examples: forEach&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>Tag Plugin Examples - &amp;lt;c:forEach>&lt;/h1>
+
+    &lt;hr>
+    &lt;/br>
+    &lt;a href="notes.html">Plugin Introductory Notes&lt;font &lt;font color="#0000FF">&lt;/
+a>
+    &lt;br/>
+    &lt;a href="howto.html">Brief Instructions for Writing Plugins&lt;font color="#0000
+FF">&lt;/a>
+    &lt;br/> &lt;br/>
+    &lt;hr>
+
+    &lt;font color="#000000"/>
+    &lt;/br>
+
+    &lt;%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
+    &lt;%@ page import="java.util.Vector" %>
+
+    &lt;h3>Iterating over a range&lt;/h3>
+    &lt;c:forEach var="item" begin="1" end="10">
+        ${item}
+    &lt;/c:forEach>
+
+    &lt;% Vector v = new Vector();
+	v.add("One"); v.add("Two"); v.add("Three"); v.add("Four");
+
+	pageContext.setAttribute("vector", v);
+    %>
+
+    &lt;h3>Iterating over a Vector&lt;/h3>
+
+    &lt;c:forEach items="${vector}" var="item" >
+	${item}
+    &lt;/c:forEach>
+  &lt;/body>
+&lt;/html> 
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/howto.html b/tomcat-uid/webapps/examples/jsp/tagplugin/howto.html
new file mode 100644
index 0000000..02e746d
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/howto.html
@@ -0,0 +1,45 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+  <head>
+    <title>Tag Plugin Implementation</title>
+  </head>
+  <body>
+    <h2>How to write tag plugins</h2>
+    <p>
+      To write a plugin, you'll need to download the source for Tomcat 5.
+      There are two steps:
+    <ol>
+      <li>
+        Implement the plugin class.<p/>
+        This class, which implements 
+        <tt>org.apache.jasper.compiler.tagplugin.TagPlugin</tt>
+        instructs Jasper what Java codes to generate in place of the tag
+        handler calls.
+        See Javadoc for <tt>org.apache.jasper.compiler.tagplugin.TagPlugin</tt>
+        for details.
+      </li>
+
+      <li>
+        Create the plugin descriptor file <tt> WEB-INF/tagPlugins.xml</tt><p/>
+        This file
+        specifies the plugin classes and their corresponding tag handler
+        classes.
+      </li>
+    </ol>
+  </body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/if.html b/tomcat-uid/webapps/examples/jsp/tagplugin/if.html
new file mode 100644
index 0000000..a338e17
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/if.html
@@ -0,0 +1,36 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+<head>
+<title>View Source Code</title>
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF">
+  <a href="if.jsp">
+    <img src="../images/execute.gif" align="right" border="0"></a>
+  <a href="../index.html">
+    <img src="../images/return.gif" width="24" height="24" align="right" border="0">
+  </a></font>
+</p>
+
+<h3>
+  <a href="if.jsp.html">Source Code for if.jsp<font color="#0000FF"/></a>
+</h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/if.jsp b/tomcat-uid/webapps/examples/jsp/tagplugin/if.jsp
new file mode 100644
index 0000000..ad9414a
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/if.jsp
@@ -0,0 +1,45 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+  <head>
+    <title>Tag Plugin Examples: if</title>
+  </head>
+  <body>
+    <h1>Tag Plugin Examples - &lt;c:if></h1>
+
+    <hr>
+    </br>
+    <a href="notes.html">Plugin Introductory Notes<font <font color="#0000FF"></a>
+    <br/>
+    <a href="howto.html">Brief Instructions for Writing Plugins<font color="#0000FF"></a>
+    <br/> <br/>
+    <hr>
+
+    <font color="#000000"/>
+    </br>
+    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
+
+    <h3>Set the test result to a variable</h3>
+    <c:if test="${1==1}" var="theTruth" scope="session"/>
+    The result of testing for (1==1) is: ${theTruth}
+
+    <h3>Conditionally execute the body</h3>
+    <c:if test="${2>0}">
+	It's true that (2>0)!
+    </c:if>
+  </body>
+</html> 
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/if.jsp.html b/tomcat-uid/webapps/examples/jsp/tagplugin/if.jsp.html
new file mode 100644
index 0000000..efcefe4
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/if.jsp.html
@@ -0,0 +1,47 @@
+<html><body><pre>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;html>
+  &lt;head>
+    &lt;title>Tag Plugin Examples: if&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1>Tag Plugin Examples - &amp;lt;c:if>&lt;/h1>
+
+    &lt;hr>
+    &lt;/br>
+    &lt;a href="notes.html">Plugin Introductory Notes&lt;font &lt;font color="#0000FF">&lt;/a>
+    &lt;br/>
+    &lt;a href="howto.html">Brief Instructions for Writing Plugins&lt;font color="#0000FF">&lt;/a>
+    &lt;br/> &lt;br/>
+    &lt;hr>
+
+    &lt;font color="#000000"/>
+    &lt;/br>
+    &lt;%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
+
+    &lt;h3>Set the test result to a variable&lt;/h3>
+    &lt;c:if test="${1==1}" var="theTruth" scope="session"/>
+    The result of testing for (1==1) is: ${theTruth}
+
+    &lt;h3>Conditionally execute the body&lt;/h3>
+    &lt;c:if test="${2>0}">
+	It's true that (2>0)!
+    &lt;/c:if>
+  &lt;/body>
+&lt;/html> 
+</pre></body></html>
diff --git a/tomcat-uid/webapps/examples/jsp/tagplugin/notes.html b/tomcat-uid/webapps/examples/jsp/tagplugin/notes.html
new file mode 100644
index 0000000..281a74c
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/tagplugin/notes.html
@@ -0,0 +1,41 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+  <head>
+    <title>Tag Plugin Introduction</title>
+  </head>
+  <body>
+    <h2>Tag Plugins: Introductory Notes</h2>
+    <p>
+      Tomcat 5 provides a framework for implementing tag plugins.  The
+      plugins instruct Jasper, at translation time, to replace tag handler
+      calls with Java scriptlets.
+      The framework allows tag library authors to implement plugins for
+      their tags.
+    </p>
+    <p>
+      Tomcat 5 is released with plugins for several JSTL tags.  Note
+      that these plugins work with JSTL 1.1 as well as JSTL 1.0, though
+      the examples uses JSTL 1.1 and JSP 2.0.  
+      These plugins are not complete (for instance, some item types not
+      handled in &lt;c:if>).
+      They do serve as examples to show plugins in action (just
+      examine the generated Java files), and how they can be implemented.
+    </p>
+  </body>
+</html>
+
diff --git a/tomcat-uid/webapps/examples/jsp/xml/xml.html b/tomcat-uid/webapps/examples/jsp/xml/xml.html
new file mode 100644
index 0000000..80907a5
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/xml/xml.html
@@ -0,0 +1,31 @@
+<html>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<head>
+<title>Untitled Document</title>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+
+<body bgcolor="#FFFFFF">
+<p><font color="#0000FF"><a href="xml.jsp"><img src="../images/execute.gif" align="right" border="0"></a><a href="../index.html"><img src="../images/return.gif" width="24" height="24" align="right" border="0"></a></font></p>
+
+<h3><a href="xml.jsp.html">Source Code for XML syntax Example<font color="#0000FF"></a>
+  </font> </h3>
+
+</body>
+</html>
diff --git a/tomcat-uid/webapps/examples/jsp/xml/xml.jsp b/tomcat-uid/webapps/examples/jsp/xml/xml.jsp
new file mode 100644
index 0000000..e7ff43b
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/xml/xml.jsp
@@ -0,0 +1,70 @@
+<?xml version="1.0"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page"
+  version="1.2">
+<jsp:directive.page contentType="text/html"/>
+<jsp:directive.page import="java.util.Date, java.util.Locale"/>
+<jsp:directive.page import="java.text.*"/>
+
+<jsp:declaration>
+  String getDateTimeStr(Locale l) {
+    DateFormat df = SimpleDateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM, l);
+    return df.format(new Date());
+  }
+</jsp:declaration>
+
+<html>
+<head>
+  <title>Example JSP in XML format</title>
+</head>
+
+<body>
+This is the output of a simple JSP using XML format. 
+<br />
+
+<div>Use a jsp:scriptlet to loop from 1 to 10: </div>
+<jsp:scriptlet>
+// Note we need to declare CDATA because we don't escape the less than symbol
+<![CDATA[
+  for (int i = 1; i<=10; i++) {
+    out.println(i);
+    if (i < 10) {
+      out.println(", ");
+    }
+  }
+]]>
+</jsp:scriptlet>
+
+<!-- Because I omit br's end tag, declare it as CDATA -->
+<![CDATA[
+  <br><br>
+]]>
+
+<div align="left">
+  Use a jsp:expression to write the date and time in the browser's locale: 
+  <jsp:expression>getDateTimeStr(request.getLocale())</jsp:expression>
+</div>
+
+
+<jsp:text>
+  &lt;p&gt;This sentence is enclosed in a jsp:text element.&lt;/p&gt;
+</jsp:text>
+
+</body>
+</html>
+</jsp:root>
diff --git a/tomcat-uid/webapps/examples/jsp/xml/xml.jsp.html b/tomcat-uid/webapps/examples/jsp/xml/xml.jsp.html
new file mode 100644
index 0000000..00d2980
--- /dev/null
+++ b/tomcat-uid/webapps/examples/jsp/xml/xml.jsp.html
@@ -0,0 +1,72 @@
+<html><body><pre>
+&lt;?xml version="1.0"?>
+&lt;!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+&lt;jsp:root xmlns:jsp="http://java.sun.com/JSP/Page"
+  version="1.2">
+&lt;jsp:directive.page contentType="text/html"/>
+&lt;jsp:directive.page import="java.util.Date, java.util.Locale"/>
+&lt;jsp:directive.page import="java.text.*"/>
+
+&lt;jsp:declaration>
+  String getDateTimeStr(Locale l) {
+    DateFormat df = SimpleDateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM, l);
+    return df.format(new Date());
+  }
+&lt;/jsp:declaration>
+
+&lt;html>
+&lt;head>
+  &lt;title>Example JSP in XML format&lt;/title>
+&lt;/head>
+
+&lt;body>
+This is the output of a simple JSP using XML format. 
+&lt;br />
+
+&lt;div>Use a jsp:scriptlet to loop from 1 to 10: &lt;/div>
+&lt;jsp:scriptlet>
+// Note we need to declare CDATA because we don't escape the less than symbol
+&lt;![CDATA[
+  for (int i = 1; i&lt;=10; i++) {
+    out.println(i);
+    if (i &lt; 10) {
+      out.println(", ");
+    }
+  }
+]]>
+&lt;/jsp:scriptlet>
+
+&lt;!-- Because I omit br's end tag, declare it as CDATA -->
+&lt;![CDATA[
+  &lt;br>&lt;br>
+]]>
+
+&lt;div align="left">
+  Use a jsp:expression to write the date and time in the browser's locale: 
+  &lt;jsp:expression>getDateTimeStr(request.getLocale())&lt;/jsp:expression>
+&lt;/div>
+
+
+&lt;jsp:text>
+  &amp;lt;p&amp;gt;This sentence is enclosed in a jsp:text element.&amp;lt;/p&amp;gt;
+&lt;/jsp:text>
+
+&lt;/body>
+&lt;/html>
+&lt;/jsp:root>
+</pre></body></html>
