.html
* file) and its corresponding compiled form (.class file). This
* class performs the compilation, handling the dependancies based on file
* timestamps, itself.
*
* At the moment this class has an unnecessary dependacy on ServletException
* which should be removed so that is can exist cleanly outside a servlet container.
*
* @author bmb6jrm
* @see org.bodington.servlet.template.LegacyTemplate
*/
public class XmlTemplate
{
private static final String[] expression_tag_names=
{
"literal",
"variable",
"assign",
"call",
"class"
};
private static final String[] htmlfragment_tag_names=
{
"htmlfragment"
};
private static final String[] call_tag_names=
{
"target",
"parameters"
};
private static boolean getDoneCompilerOutputCheck=false;
private static boolean getCanGetCompilerOutput = false;
// class loaders hashed against class directories
private static Hashtable class_loaders = new Hashtable();
private static DocumentBuilderFactory docbuilderfactory;
private static org.xml.sax.EntityResolver entity_resolver;
static
{
docbuilderfactory = DocumentBuilderFactory.newInstance();
docbuilderfactory.setValidating( true );
entity_resolver = new ClasspathEntityResolver(XmlTemplate.class);
}
XmlTemplateClassLoader class_loader;
XmlTemplateProcessor processor;
File xml_source;
File class_dir;
String class_name;
String class_path;
// indicates the timestamp of the version of the xml file that was
// last compiled
long compiled_xml_source_timestamp = -1;
boolean compiling;
//Hashtable attribute_tables = new Hashtable();
PrintWriter writer=null;
boolean preparation_done;
String html_body_class=null;
Hashtable template_variable_class_table;
/**
* Create an instance of this class.
* @param xml_source the absolute path to the template source file.
* @param class_dir the destination directory of the compiled class file.
* @param class_name the name of the compiled class file.
* @param class_path the CLASSPATH to be used for the template
* java -> bytecode compilation stage.
*/
public XmlTemplate( File xml_source, File class_dir, String class_name, String class_path )
{
this.xml_source = xml_source;
this.class_dir = class_dir;
this.class_name = class_name;
this.class_path = class_path;
processor = null;
compiling = false;
class_loader = getSuitableClassLoader();
File class_file = class_loader.getClassFile( class_name );
// We note the compiled XML timestamp in case it changes within the lifespan
// of this object.
if ( class_file !=null && xml_source!=null && xml_source.exists() )
this.compiled_xml_source_timestamp = xml_source.lastModified();
}
/**
* Create an instance of this class. This version of the constructor, uses
* the method {@link #templateToClassName(String)} to generate the class
* name, by relativizing the template name against the value of the
* srcdir argument.
* @param srcdir the base directory containing the template source
* @param xml_source the absolute path to the template source file.
* @param class_dir the destination directory of the compiled class file.
* @param class_path the CLASSPATH to be used for the
* template java -> bytecode compilation stage.
* @see #XmlTemplate(File, File, String, String)
*/
public XmlTemplate( File srcdir, File xml_source, File class_dir,
String class_path )
{
this( xml_source, class_dir, templateToClassName( relativize( srcdir,
xml_source ) ), class_path );
}
/**
* Relativize one file against the other. The first argument is the base
* directory and the second is the file to be relativized against it.
* @param baseDir the base directory to be relativized against.
* @param file the file to be relativized.
* @return the second argument in relativized form.
* @see java.net.URI
*/
protected static String relativize( File baseDir, File file )
{
URI baseURI = baseDir.toURI();
URI uri = baseURI.relativize( file.toURI() );
return uri.toString();
}
/**
* Create a class name for the specified template name. This method expects
* the argument to be in relative URI form. An example of this would
* be style_default/default/index.html.
* @param template the path to the template (in relative URI form).
* @return the corresponding class name.
*/
protected static String templateToClassName( String template )
{
StringBuffer sb = new StringBuffer( template );
// prepend "working.":
sb.insert( 0, "working." );
// replace first "/" with "_":
int i = sb.indexOf( "/" );
sb.replace( i, i + 1, "_" );
// replace last "/" with ".template_":
i = sb.lastIndexOf( "/" );
sb.replace( i, i + 1, ".template_" );
// replace all "-" with "_":
while ( (i = sb.indexOf( "-" )) != -1 )
sb.replace( i, i + 1, "_" );
// remove ".html" from end:
sb.delete( sb.length() - ".html".length(), sb.length() );
return sb.toString();
}
private ErrorHandler errorHandler;
/**
* Set the error handler to be used for this template. This method enables
* a caller to register a handler for XML template parsing errors and
* warnings.
* @param errorHandler the error handler to be used.
* @see #getErrorHandler()
*/
public void setErrorHandler(ErrorHandler errorHandler)
{
this.errorHandler = errorHandler;
}
/**
* Get the error handler used by this template.
* @return the error handler used by this template.
* @see #setErrorHandler(ErrorHandler)
*/
public ErrorHandler getErrorHandler()
{
return errorHandler;
}
private int timestampLatency = 5;
/**
* Set the value of the timestampLatency property. When this class carries
* out a dependancy check to see whether or not the HTML templates needs to
* be compiled or not, it looks at the timestamps of the HTML file and the
* corresponding class file. If the HTML file is newer than the class file,
* this indicates that a compilation is required. The value of this property
* can be used to add a latency to this dependancy check. For
* example, with a value of 5 the HTML file can be upto 5
* seconds older than the class file, before {@link #needsCompiling()} will
* return a value of true. At design-time users will
* probably want to give this property a value of 0 (for
* obvious reasons). By default the value of this property is 5.
*
* NOTE: the need for this property arose when deploying on
* Tomcat v5.5. This is because it was discovered that when deploying in the
* form of a war, the unpacking algorithm always unpacked the class files
* before the HTML files. This meant that the HTML templates were always
* considered to be newer, thus rendering pre-compilation futile! Therefore,
* this property is set to 5 by default, but can be
* overridden if required.
* @param timestampLatency the new value of the timestampLatency property.
* @see #needsCompiling()
* @see #getTimestampLatency()
*/
public void setTimestampLatency( int timestampLatency )
{
this.timestampLatency = timestampLatency;
}
/**
* Get the value of the timestampLatency property (in whole seconds).
* @return the value of the timestampLatency property (in whole seconds).
* @see #setTimestampLatency(int)
*/
public int getTimestampLatency()
{
return timestampLatency;
}
/**
* Indicates whether the template represented by this object need compiling.
* This method compares the timestamps of the template HTML file and it's
* corresponding class file. In general, if the timestamp of the HTML file
* is newer than the timestamp of the class file, then this method returns
* true.
* @return true if the template represented by this object
* needs compiling, otherwise false.
* @see #setTimestampLatency(int)
*/
public synchronized boolean needsCompiling()
{
// The HTML file may get deleted within the life-cycle of this object ...
if ( !xml_source.exists() )
return false;
// needs compiling if the template was replaced with a
// version that has a different timestamp (older or newer)
// than one that was loaded earlier in the lifetime of
// this Template object
long xml_source_timestamp = xml_source.lastModified();
if ( xml_source_timestamp != compiled_xml_source_timestamp )
return true;
// needs compiling if the class file doesn't exist
File class_file = class_loader.getClassFile( class_name );
if ( class_file==null || !class_file.exists() )
return true;
// needs compiling if the class file is older than the
// source file (taking timestampLatency into account).
long class_timestamp=class_file.lastModified();
long latency = getTimestampLatency() * 1000; // whole seconds -> ms.
return class_timestamp < (xml_source_timestamp - latency);
}
/**
* Get an object to handle the compilation of this template in a web-app.
* This method actually triggers the compilation process (if required) of
* the underlying template. This signature of this method is clearly
* tightly-coupled to a servlet-driven world, but it can be called from
* elsewhere in order to drive template compilation. It has code to handle
* template compilation in a multi-threaded environment. If in a
* single-threaded environment and / or outside of a servlet-driven world,
* you can call {@link #compile()} directly instead.
* @return an object to handle the compilation of this template in a
* web-app.
* @throws SAXParseException if there is some problem parsing an XML
* template.
* @throws IOException if there is some problem parsing a legacy template.
* @throws ParserConfigurationException if there is some problem configuring
* the XML parser.
* @throws SAXException if there is some other problem with XML parsing.
* @throws ServletException if there are compilation problems, but delivered
* in a form targeted at objects in the servlet world.
* @throws Exception if there is some other problem (most likely configuring
* the java compiler).
* @see #compile()
*/
public XmlTemplateProcessor getProcessor() throws SAXParseException,
IOException, ParserConfigurationException, SAXException,
ServletException, Exception
{
if ( !xml_source.exists() && !xml_source.isFile() )
return null;
if ( needsCompiling() )
{
synchronized ( this )
{
// if another thread is updating the class file
// make do with the current one - don't bother waiting
if ( processor != null && compiling )
return processor;
// if there isn't a current processor wait for the
// compilation to complete
if ( compiling )
{
while ( compiling )
try
{wait();} catch ( InterruptedException e )
{}
return processor;
}
// make sure this flag is set before anyone enters this
// block
compiling = true;
}
try
{
compile();
loadProcessor();
return processor;
}
finally
{
// guaranteed to clear the flag
compiling = false;
synchronized ( this )
{
// allow all the waiting threads to pick up
// the new processor
notifyAll();
}
}
}
// doesn't need compiling but may need to be loaded.
if ( processor == null || class_loader.isClassRecompiled( class_name ) )
loadProcessor();
return processor;
}
private void loadProcessor()
{
try
{
Class cl = class_loader.loadClass( class_name, true );
processor = (XmlTemplateProcessor)cl.newInstance();
}
catch ( Throwable th)
{
processor = new XmlTemplateErrorProcessor( th.getMessage() );
}
}
private PrintWriter error_writer = null;
private boolean isDefaultErrorWriter = true;
/**
* Get the object to write java compilation error messages to.
* @return the object to write java compilation error messages to.
* @see #isDefaultErrorWriter()
*/
public PrintWriter getErrorWriter()
{
return error_writer;
}
/**
* Set the object to write java compilation error messages to.
* @param error_writer the object to write java compilation error messages
* to.
* @see #isDefaultErrorWriter()
* @throws NullPointerException if the argument is null.
*/
public void setErrorWriter(PrintWriter error_writer)
{
if (error_writer != null)
{
this.error_writer = error_writer;
isDefaultErrorWriter = false;
}
else
throw new NullPointerException("The argument must be non-null.");
}
/**
* Indicates whether this instance is using the default error writer. By
* default, instances of this class will write any errors from the java
* compilation stage to a corresponding file. This file will be in the
* same directory as the generated java file. It will have the same name,
* but with the suffix .err.txt.
* @return true if this instance is using the default error
* writer, otherwise false.
* @see #setErrorWriter(PrintWriter)
* @see #getErrorWriter()
*/
public boolean isDefaultErrorWriter()
{
return isDefaultErrorWriter;
}
/**
* Compile the XML template.
* @param xml_document a document representing the XML template.
* @param directory the directory where the java source code and the binary
* class file should be output.
* @param class_name the name of the template binary class file.
* @param class_path the CLASSPATH to be used by the java compiler.
* @return the return value of the java compiler.
* @throws ServletException if there are compilation problems, but delivered
* in a form targeted at objects in the servlet world.
* @throws IOException if there is some kind of problem with legacy template
* compilation.
* @throws Exception if there is some other problem (most likely configuring
* the java compiler).
*/
private int compile( Document xml_document, File directory, String class_name, String class_path )
throws ServletException, IOException, Exception
{
if ( !directory.exists() || !directory.isDirectory() )
throw new ServletException( "Invalid compilation directory for templates." );
String file_name = class_name.replace( '.', File.separatorChar ) + ".java";
File java_file = new File( directory, file_name );
File parent_dir = java_file.getParentFile();
if ( !parent_dir.exists() )
parent_dir.mkdirs();
writer =
new PrintWriter(
new OutputStreamWriter(
new FileOutputStream( java_file ), "US-ASCII" ) );
String unqual_class_name;
if ( class_name.indexOf( '.' ) > 0 )
{
unqual_class_name = class_name.substring( class_name.lastIndexOf( '.' )+1 );
writer.print( "package " );
writer.print( class_name.substring( 0, class_name.lastIndexOf( '.' ) ) );
writer.println( ";" );
}
else
unqual_class_name = class_name;
writer.println( "import org.bodington.servlet.*;" );
writer.println( "import org.bodington.servlet.template.*;" );
writer.println( "import java.io.*;" );
writer.println( "import javax.servlet.*;" );
writer.println( "import javax.servlet.http.*;" );
writer.println( "public class " + unqual_class_name );
writer.println( " extends XmlTemplateProcessor" );
writer.println( "{" );
writer.println( " public " + unqual_class_name + "()" );
writer.println( " {" );
writer.println( " }" );
writer.println( " public void process( Request request, Response response )" );
writer.println( " throws IOException, ServletException" );
writer.println( " {" );
template_variable_class_table = new Hashtable();
template_variable_class_table.put( "request", Request.class );
template_variable_class_table.put( "response", Response.class );
createTemplateVariable( "writer", PrintWriter.class );
writer.println( "writer=null;" );
preparation_done = false;
// needed for all HTML templates
writer.println( "response.disableCaching();" );
try
{
Element template_element = xml_document.getDocumentElement();
if ( !"template".equals( template_element.getTagName() ) )
throw new IOException( "Invalid template file." );
compileElement( template_element );
writer.println( " }" );
writer.println( " }" );
writer.close();
writer = null;
if (isDefaultErrorWriter())
{
File error_log_file = new File( directory,
class_name.replace( '.', File.separatorChar ) + ".err.txt" );
error_writer = new PrintWriter( new FileWriter( error_log_file ) );
error_writer.println( "Compilation messages..." );
error_writer.println( "-classpath " + class_path );
}
// JDK 1.4.0 does not have the static method
// int compile(String[], PrintWriter), so check to see if available and
// fall back if not. If this fails don't try again for lifetime of JVM.
if ( !getDoneCompilerOutputCheck )
{
try
{
Main.class.getMethod("compile",
new Class[] {new String[0].getClass(), PrintWriter.class});
getCanGetCompilerOutput = true;
}
catch ( Exception e )
{
getCanGetCompilerOutput = false;
}
finally
{
getDoneCompilerOutputCheck = true;
}
}
if (!getCanGetCompilerOutput && isDefaultErrorWriter())
{
error_writer.println();
error_writer.println( "*** NOTE: Compiler errors not available "
+ "because the compiler in your JDK does not have the required "
+ "method. Try upgrading to JDK 1.4.2 / 1.5 ***" );
}
String[] args = null;
args = new String[]
{
"-classpath", class_path,
"-sourcepath", directory.getAbsolutePath(),
"-d", directory.getAbsolutePath(),
"-source", "1.4",
java_file.getAbsolutePath()
};
// NOTE: whilst the below will *run* on J2SDK 1.4.0, it will not
// *build*! For that, reflection gymnastics is required.
javaCompileStatus = getCanGetCompilerOutput
? Main.compile(args, error_writer) : Main.compile(args);
if (isDefaultErrorWriter())
{
error_writer.println();
error_writer.println( "Compilation exit code = " + javaCompileStatus );
}
}
finally
{
if ( writer != null )
{
writer.close();
writer = null;
}
if ( isDefaultErrorWriter() && error_writer!=null )
error_writer.close();
}
return javaCompileStatus;
}
/**
* A constant representing java compile success.
*/
public static final int JAVA_COMPILE_SUCCESS = 0;
private int javaCompileStatus = JAVA_COMPILE_SUCCESS;
/**
* Get the value of the java compile status. This is the value returned by
* the java compiler (javac) when it last successfully compiled the
* template. A value equal to {@link #JAVA_COMPILE_SUCCESS} indicates that
* the template compiled successfully.
* @return the value of the java compile status.
* @see #JAVA_COMPILE_SUCCESS
*/
public int getJavaCompileStatus()
{
return javaCompileStatus;
}
/**
* Compile this template. This template will only be compiled if it requires
* compiling (based on the timestamps of the input and output files).
*
* There are essentially 3 stages to compiling a template: *
.java file.
* .java file into a .class
* file.
*
* The process can fail at any stage. For example, stage 2 can generate a
* .java file that will not compile. This accounts for the
* numerous exceptions that can get thrown. An entirely successful
* invocation of this method results in no exceptions being thrown and a
* return result equal to {@link #JAVA_COMPILE_SUCCESS}.
* @return the return value of the java compiler.
* @throws SAXParseException if there is some problem parsing an XML
* template.
* @throws IOException if there is some problem parsing a legacy template.
* @throws ParserConfigurationException if there is some problem configuring
* the XML parser.
* @throws SAXException if there is some other problem with XML parsing.
* @throws ServletException if there are compilation problems, but delivered
* in a form targeted at objects in the servlet world.
* @throws Exception if there is some other problem (most likely configuring
* the java compiler).
* @see #JAVA_COMPILE_SUCCESS
*/
public int compile() throws SAXParseException, IOException,
ParserConfigurationException, SAXException, ServletException, Exception
{
if ( needsCompiling() )
{
compiled_xml_source_timestamp = xml_source.lastModified();
if ( isXml() )
{
DocumentBuilder docbuilder =
docbuilderfactory.newDocumentBuilder();
docbuilder.setEntityResolver( entity_resolver );
docbuilder.setErrorHandler( errorHandler );
Document xml_document = docbuilder.parse( xml_source );
javaCompileStatus = compile( xml_document, class_dir,
class_name, class_path );
}
else
{
LegacyTemplate legacy = new LegacyTemplate();
javaCompileStatus = legacy.compile( xml_source, class_dir,
class_name, class_path );
}
}
return javaCompileStatus;
}
private void compileElement( Element element )
throws ServletException, IOException
{
String tag_name = element.getTagName();
String class_att;
if ( "template".equals( tag_name ) )
{
String facilityclass = element.getAttribute( "facilityclass" );
if ( facilityclass == null || facilityclass.length() == 0 )
{
createTemplateVariable( "facility", Facility.class );
writer.println( "facility=request.getFacility();" );
}
else
{
Class c=null;
try
{
c = Class.forName( facilityclass );
}
catch ( ClassNotFoundException e )
{
throw new ServletException( "Class not found: " + facilityclass );
}
createTemplateVariable( "facility", c );
writer.print( "facility=(" );
writer.print( facilityclass );
writer.println( ")request.getFacility();" );
}
compileChildren( element, false, false );
}
else if ( "preparation".equals( tag_name ) )
{
compileChildren( element, false, false );
preparation_done = true;
}
else if ( "declare".equals( tag_name ) )
{
compileDeclare( element );
}
else if ( "building".equals( tag_name) )
{
compileBuilding ( element );
}
else if ( "assign".equals( tag_name ) )
{
compileAssign( element );
}
else if ( "call".equals( tag_name ) )
{
compileCall( element );
writer.println( ";" );
}
else if ( "if".equals( tag_name ) )
{
compileIf( element );
}
else if ( "htmlfragment".equals( tag_name ) )
{
compileChildren( element, false, true );
}
else if ( "textarea".equals( tag_name ) )
{
compileTextarea( element );
}
else if ( "filter".equals( tag_name ) )
{
compileFilter( element );
}
else
{
if ( "html".equals( tag_name ) )
{
preparation_done = true;
writer.println( " response.setContentType(\"text/html; charset=utf-8\");" );
writer.println( " writer = response.getWriter();" );
// declare as loose HTML4 - this is an attempt to get I.E. 6 in standards mode
writer.println( " writer.println( \"\" );" );
}
if ( "body".equals( tag_name ) )
{
class_att = element.getAttribute( "class" );
// make compile time record of class
html_body_class = class_att;
// make run time record of class
if ( class_att!=null && class_att.length() > 0 )
{
writer.print( " response.setHtmlBodyClass( \"" );
writer.print( class_att );
writer.println( "\" );" );
}
}
compileChildren( element, true, true );
}
}
/**
* Compile a textarea tag. This needs special handling as normally
* the textarea tag is collapsed by the XML parser from two tags
* to one and HTML needs two.
* @param element The textarea element from the XML parsing.
*/
private void compileTextarea(Element element) throws ServletException, IOException
{
writer.print("writer.print(\"\");");
}
/**
* Support for the legacy templates building tag.
* @param element The node element.
*/
private void compileBuilding(Element element)
{
NamedNodeMap attributes = element.getAttributes();
writer.write("insertInteractive( request, writer, arrayToMap(new String[][]{");
for (int attributeNo = 0; attributeNo < attributes.getLength(); attributeNo++)
{
if (attributeNo > 0)
{
writer.write(",");
}
Node attribute = attributes.item(attributeNo);
writer.write( "{ \""+ attribute.getNodeName()+ "\" , \""+ attribute.getNodeValue()+ "\"}\n");
}
writer.write("}));\n");
}
private void compileChildren( Element element, boolean output_parent, boolean output_children )
throws ServletException, IOException
{
int i, j, k;
Node child_node;
Element child_element;
Attr child_attribute;
CharacterData child_chars;
boolean start_tag_open=false;
boolean element_empty=true;
if ( output_parent )
{
start_tag_open = true;
writer.print( " writer.print( \"<" );
writer.print( element.getTagName() );
writeAttributes(element);
}
NodeList nodelist = element.getChildNodes();
for ( i=0; i< nodelist.getLength(); i++ )
{
child_node = nodelist.item( i );
if ( child_node.getNodeType() == Node.ELEMENT_NODE )
{
if ( start_tag_open )
{
writer.println( ">\" );" );
start_tag_open = false;
}
element_empty = false;
child_element = (Element)child_node;
compileElement( child_element );
}
if ( output_children && preparation_done &&
(child_node.getNodeType() == Node.CDATA_SECTION_NODE ||
child_node.getNodeType() == Node.TEXT_NODE ) )
{
if ( start_tag_open )
{
writer.println( ">\" );" );
start_tag_open = false;
}
element_empty = false;
child_chars = (CharacterData)child_node;
int l = child_chars.getLength();
String chunk;
String hex;
if ( l > 0 )
for ( j=0; j