jkesselm 00/10/05 09:21:23
Modified: java/src/org/apache/xalan/processor CompiledTemplate.java
CompilingStylesheetHandler.java
Log:
Factoring out boilerplate
Revision Changes Path
1.2 +101 -3
xml-xalan/java/src/org/apache/xalan/processor/CompiledTemplate.java
Index: CompiledTemplate.java
===================================================================
RCS file:
/home/cvs/xml-xalan/java/src/org/apache/xalan/processor/CompiledTemplate.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- CompiledTemplate.java 2000/09/20 23:33:09 1.1
+++ CompiledTemplate.java 2000/10/05 16:21:16 1.2
@@ -1,6 +1,104 @@
-/** Interface for generated template classes */
+/** Abstract superclass for generated template classes
+ (It had been a template, but I want to factor out some "boilerplate" code)
+ */
package org.apache.xalan.processor;
-public interface CompiledTemplate
+import org.apache.xalan.templates.ElemTemplate;
+
+public abstract class CompiledTemplate
+extends ElemTemplate
{
- public void execute(org.apache.xalan.transformer.TransformerImpl
transformer,org.w3c.dom.Node sourceNode,org.apache.xalan.utils.QName mode)
throws org.xml.sax.SAXException;
+ // Object[] m_interpretArray is used to
+ // bind to nodes we don't yet know how to compile.
+ // Set at construction. ElemTemplateElements and AVTs...
+ protected java.lang.Object[] m_interpretArray;
+
+ // Namespace context tracking. Note that this is dynamic state
+ // during execution, _NOT_ the static state tied to a single
+ // ElemTemplateElement during parsing. Also note that it needs to
+ // be set in execute() but testable in getNamespaceForPrefix --
+ // and the latter, most unfortunately, is not passed the xctxt so
+ // making that threadsafe is a bit ugly.
+ protected java.util.Hashtable m_nsThreadContexts=new java.util.Hashtable();
+
+
+ /** Accessor to let interpretive children query current namespace state.
+ * Note that unlike the interpreted version, the namespace state of this
+ * code changes over time... and that we need to maintain a unique state
+ * for each thread if we're to support multitasking.
+ */
+ public String getNamespaceForPrefix(String nsPrefix)
+ {
+ String nsuri="";
+ org.xml.sax.helpers.NamespaceSupport nsSupport=
+ (org.xml.sax.helpers.NamespaceSupport)
+ m_nsThreadContexts.get(Thread.currentThread());
+ if(null!=nsSupport)
+ nsuri=nsSupport.getURI(nsPrefix);
+ if(null==nsuri || nsuri.length()==0)
+ nsuri=m_parentNode.getNamespaceForPrefix(nsPrefix);
+ return nsuri;
+ }
+
+
+ /** public constructor: Copy values from original
+ * template object, pick up "uncompiled children"
+ * array from compilation/instantiation process,
+ * and set the Locator information explicitly.
+ * (I want the locator to be visible as literals
+ * in the generated code, for debugging purposes.)
+ */
+ public CompiledTemplate(ElemTemplate original,
+ int lineNumber, int columnNumber,
+ String publicId,String systemId,
+ java.lang.Object[] interpretArray)
+ {
+ org.xml.sax.helpers.LocatorImpl locator=
+ new org.xml.sax.helpers.LocatorImpl();
+ locator.setLineNumber(lineNumber);
+ locator.setColumnNumber(columnNumber);
+ locator.setPublicId(publicId);
+ locator.setSystemId(systemId);
+ setLocaterInfo(locator); // yes, there's an or/er clash
+
+ // uncompiled descendents/children
+ this.m_interpretArray=interpretArray;
+
+ // other context values which seem to be needed
+ setMatch(original.getMatch());
+ setMode(original.getMode());
+ setName(original.getName());
+ setPriority(original.getPriority());
+ setStylesheet(original.getStylesheet());
+
+ // Reparent the interpreted ElemTemplateElements,
+ // to break their dependency on interpretive code.
+ // AVTs in this array don't need proceessing, as they are
+ // apparently not directly aware of their Elements.
+
+ for(int i=0;i<m_interpretArray.length;++i)
+ {
+ if(m_interpretArray[i] instanceof
org.apache.xalan.templates.ElemTemplateElement)
+ {
+ org.apache.xalan.templates.ElemTemplateElement ete=
+ (org.apache.xalan.templates.ElemTemplateElement)
+ m_interpretArray[i];
+
+ // Append alone is not enough; it's lightweight, and assumes
+ // the child had no previous parent. Need to remove first.
+ // (We know that there _was_ a previous parent, of course!)
+ appendChild(ete.getParentElem().removeChild(ete));
+ }
+ }
+ } // Constructor initialization ends
+
+
+ /** Main entry point for the Template transformation.
+ * It's abstract in CompiledTemplate, but is filled in
+ * when the actual template code is synthesized.
+ */
+ public abstract void execute(
+ org.apache.xalan.transformer.TransformerImpl
transformer,
+ org.w3c.dom.Node sourceNode,
+ org.apache.xalan.utils.QName mode)
+ throws org.xml.sax.SAXException;
}
1.5 +27 -47
xml-xalan/java/src/org/apache/xalan/processor/CompilingStylesheetHandler.java
Index: CompilingStylesheetHandler.java
===================================================================
RCS file:
/home/cvs/xml-xalan/java/src/org/apache/xalan/processor/CompilingStylesheetHandler.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- CompilingStylesheetHandler.java 2000/09/28 15:56:38 1.4
+++ CompilingStylesheetHandler.java 2000/10/05 16:21:17 1.5
@@ -94,6 +94,9 @@
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
+// Java Compiler support, being swiped from BSF
+// TODO: ADOPT OR ADAPT THIS LOGIC *****
+import com.ibm.cs.util.JavaUtils;
/**
* <meta name="usage" content="advanced"/>
@@ -227,23 +230,23 @@
try
{
- // public class ACompiledTemplate000... extends ElemTemplate
- // implements CompiledTemplate
+ // public class ACompiledTemplate000...
+ // extends CompiledTemplate (partly abstract superclass)
synthetic.Class tClass=
synthetic.Class.declareClass(className);
tClass.setModifiers(java.lang.reflect.Modifier.PUBLIC);
- tClass.setSuperClass(ElemTemplate.class);
-
tClass.addImplements(tClass.forName("org.apache.xalan.processor.CompiledTemplate"));
+
tClass.setSuperClass(tClass.forName("org.apache.xalan.processor.CompiledTemplate"));
- // Object[] interpretArray is used to
+/*****
+ // Object[] m_interpretArray is used to
// bind to nodes we don't yet know how to compile.
// Set at construction. ElemTemplateElements and AVTs...
// Synthesis needs a more elegant way to declare array classes
// given a base class...
- synthetic.reflection.Field interpretArray=
- tClass.declareField("interpretArray");
+ synthetic.reflection.Field m_interpretArray=
+ tClass.declareField("m_interpretArray");
// org.apache.xalan.templates.ElemTemplateElement
- interpretArray.setType(tClass.forName("java.lang.Object[]"));
+ m_interpretArray.setType(tClass.forName("java.lang.Object[]"));
// Namespace context tracking. Note that this is dynamic state
// during execution, _NOT_ the static state tied to a single
@@ -270,6 +273,7 @@
+"nsuri=m_parentNode.getNamespaceForPrefix(nsprefix);\n"
+"return nsuri;\n"
);
+*****/
// public constructor: Copy values from original
// template object, pick up "uncompiled children"
@@ -277,45 +281,21 @@
synthetic.reflection.Constructor ctor=
tClass.declareConstructor();
ctor.setModifiers(java.lang.reflect.Modifier.PUBLIC);
- ctor.addParameter(tClass.getSuperclass(),"original");
- ctor.addParameter(interpretArray.getType(),"interpretArray");
+ ctor.addParameter(tClass.forClass(ElemTemplate.class),"original");
+
ctor.addParameter(tClass.forName("java.lang.Object[]"),"interpretArray");
- // It'd be easiest in most cases to copy values direct from the
+ // It'd be easiest to let the c'tor copy values direct from the
// "original" template during instantiation. However, I want to
make
- // as many as possible into literals, for efficiency and
debugability.
+ // some into literals, for the sake of debugability.
ctor.getBody().append(
- "org.xml.sax.helpers.LocatorImpl locator=new
org.xml.sax.helpers.LocatorImpl();\n"
- +"locator.setLineNumber("+source.getLineNumber()+");\n"
-
+"locator.setColumnNumber("+source.getColumnNumber()+");\n"
-
+"locator.setPublicId("+makeQuotedString(source.getPublicId())+");\n"
-
+"locator.setSystemId("+makeQuotedString(source.getSystemId())+");\n"
- +"setLocaterInfo(locator); // yes, or/er clash\n"
- +"// uncompiled descendents/children\n"
- +"this.interpretArray=interpretArray;\n"
- +"// other context values which seem to be needed\n"
- +"setMatch(original.getMatch());\n"
- +"setMode(original.getMode());\n"
- +"setName(original.getName());\n"
- +"setPriority(original.getPriority());\n"
- +"setStylesheet(original.getStylesheet());\n\n"
- //+"setLocatorInfo(new
Locator(original.getPublicID(),original.getSystemID()));\n"
-
- // Reparent the interpreted ElemTemplateElements,
- // to break their dependency on interpretive code.
- // AVTs in this array don't need proceessing, as they are
- // apparently not directly aware of their Elements.
- +"for(int i=0;i<interpretArray.length;++i)\n{\n"
- +"\tif(interpretArray[i] instanceof
org.apache.xalan.templates.ElemTemplateElement)\n"
- +"\t{\n"
- +"\torg.apache.xalan.templates.ElemTemplateElement
ete=(org.apache.xalan.templates.ElemTemplateElement)interpretArray[i];\n"
- // Append alone is not enough; it's lightweight, and assumes
- // the child had no previous parent. Need to remove first.
- // (We know that there _was_ a previous parent, of course!)
- +"\tappendChild(ete.getParentElem().removeChild(ete));\n"
- +"\t}\n}\n"
- );
+ "super(original,\n"
+
+'\t'+source.getLineNumber()+','+source.getColumnNumber()+",\n"
+ +'\t'+makeQuotedString(source.getPublicId())+",\n"
+ +'\t'+makeQuotedString(source.getSystemId())+",\n"
+ +"\tinterpretArray);\n"
+ );
- // Corresponding vector built during compilation
+ // m_interpretArray's vector built during compilation
Vector interpretVector=new Vector();
// Now for the big guns: the execute() method is where all the
@@ -464,7 +444,7 @@
int offset=interpretVector.size();
interpretVector.addElement(kid);
body.append(
-
"((org.apache.xalan.templates.ElemTemplateElement)interpretArray["+offset+"]).execute(transformer,sourceNode,mode);\n"
+
"((org.apache.xalan.templates.ElemTemplateElement)m_interpretArray["+offset+"]).execute(transformer,sourceNode,mode);\n"
);
break;
}
@@ -547,7 +527,7 @@
interpretVector.addElement(avt);
body.append(
"avtStringedValue=((org.apache.xalan.templates.AVT)"
- +"(interpretArray["+offset+"])"
+ +"(m_interpretArray["+offset+"])"
+").evaluate(xctxt,sourceNode,this,new
StringBuffer());\n"
+"if(null!=avtStringedValue)\n{\n"
);
@@ -664,7 +644,7 @@
// TODO: ***** I'm assuming I can get away with "this" as the
prefixResolver
// even in the compiled code. I'm not really convinced that's true...
return
- "(
((org.apache.xalan.templates.AVT)interpretArray["+offset+"]).evaluate(transformer.getXPathContext(),sourceNode,this,new
StringBuffer()) )"
+ "(
((org.apache.xalan.templates.AVT)m_interpretArray["+offset+"]).evaluate(transformer.getXPathContext(),sourceNode,this,new
StringBuffer()) )"
;
}
@@ -984,7 +964,7 @@
// 1.1 calls), then fall back on command line if necessary.
// But I'm having some odd problems with it right now under
// both VisualCafe and VisualJ++.
- compileOK=com.ibm.bsf.util.JavaUtils.JDKcompile(filename,classpath);
+ compileOK = JavaUtils.JDKcompile(filename,classpath);
}
else
{
