org.apache.commons.jelly.parser

## Class XMLParser

- java.lang.Object
- - org.xml.sax.helpers.DefaultHandler
  - - org.apache.commons.jelly.parser.XMLParser

All Implemented Interfaces:
  org.xml.sax.ContentHandler, org.xml.sax.DTDHandler, org.xml.sax.EntityResolver, org.xml.sax.ErrorHandler

    public class XMLParser
    extends org.xml.sax.helpers.DefaultHandler

`XMLParser` parses the XML Jelly format. The SAXParser and XMLReader portions of this code come from Digester.

Version:
  $Revision: 219726 $
Author:
  James Strachan

### Field Summary

Fields
`protected java.lang.ClassLoader` `classLoader` The class loader to use for instantiating application objects.
`protected org.xml.sax.ErrorHandler` `errorHandler` The application-supplied error handler that is notified when parsing warnings, errors, or fatal errors occur.
`protected static javax.xml.parsers.SAXParserFactory` `factory` The SAXParserFactory that is created the first time we need it.
`protected org.xml.sax.Locator` `locator` The Locator associated with our parser.
`protected java.util.Map` `namespaces` Registered namespaces we are currently processing.
`protected javax.xml.parsers.SAXParser` `parser` The SAXParser we will use to parse the input stream.
`protected org.xml.sax.XMLReader` `reader` The XMLReader used to parse digester rules.
`protected boolean` `useContextClassLoader` Do we want to use the Context ClassLoader when loading classes for instantiating new objects? Default is `false`.
`protected boolean` `validating` Do we want to use a validating parser?

### Constructor Summary

Constructors
Constructor and Description
`XMLParser()` Construct a new XMLParser with default properties.
`XMLParser(javax.xml.parsers.SAXParser parser)` Construct a new XMLParser, allowing a SAXParser to be passed in.
`XMLParser(org.xml.sax.XMLReader reader)` Construct a new XMLParser, allowing an XMLReader to be passed in.

### Method Summary

Methods
`protected void` `addExpressionScript(ScriptBlock script, Expression expression)` Adds the given Expression object to the current Script.
`protected void` `addTextScript(java.lang.String text, boolean start)` Adds the text to the current script block parsing any embedded expressions into ExpressionScript objects.
`void` `characters(char[] buffer, int start, int length)` Process notification of character data received from the body of an XML element.
`protected void` `configure()` This method is called only once before parsing occurs which allows tag libraries to be registered and so forth
`protected void` `configureStaticTagAttributes(TagScript script, org.xml.sax.Attributes list)`
`protected void` `configureTagScript(TagScript aTagScript)` Configure a newly created TagScript instance before any Expressions are created
`protected Expression` `createConstantExpression(java.lang.String tagName, java.lang.String attributeName, java.lang.String attributeValue)`
`protected Expression` `createEscapingExpression(Expression expression)`
`protected ExpressionFactory` `createExpressionFactory()`
`protected org.xml.sax.SAXException` `createSAXException(java.lang.Exception e)` Create a SAX exception which also understands about the location in the digester file where the exception occurs
`protected org.xml.sax.SAXException` `createSAXException(java.lang.String message)` Create a SAX exception which also understands about the location in the digester file where the exception occurs
`protected org.xml.sax.SAXException` `createSAXException(java.lang.String message, java.lang.Exception e)` Create a SAX exception which also understands about the location in the file where the exception occurs
`protected TagScript` `createStaticTag(java.lang.String namespaceURI, java.lang.String localName, java.lang.String qName, org.xml.sax.Attributes list)` Factory method to create a static Tag that represents some static content.
`protected TagScript` `createTag(java.lang.String namespaceURI, java.lang.String localName, org.xml.sax.Attributes list)` Factory method to create new Tag script for the given namespaceURI and name or return null if this is not a custom Tag.
`void` `endDocument()` Process notification of the end of the document being reached.
`void` `endElement(java.lang.String namespaceURI, java.lang.String localName, java.lang.String qName)` Process notification of the end of an XML element being reached.
`void` `endPrefixMapping(java.lang.String prefix)` Process notification that a namespace prefix is going out of scope.
`void` `error(SAXParseException exception)` Forward notification of a parsing error to the application supplied error handler, if any, otherwise throw a SAXException with the error.
`void` `fatalError(SAXParseException exception)` Forward notification of a fatal parsing error to the application supplied error handler, if any, otherwise throw a SAXException with the error.
`java.lang.String` `findNamespaceURI(java.lang.String prefix)` Return the currently mapped namespace URI for the specified prefix, if any; otherwise return `null`.
`java.lang.ClassLoader` `getClassLoader()` Return the class loader to be used for instantiating application objects when required.
`JellyContext` `getContext()`
`protected java.lang.String` `getCurrentURI()`
`org.xml.sax.ErrorHandler` `getErrorHandler()` Return the error handler for this XMLParser.
`ExpressionFactory` `getExpressionFactory()`
`protected java.util.Properties` `getJellyProperties()` A helper method which loads the static Jelly properties once on startup
`org.apache.commons.logging.Log` `getLogger()` Return the current Logger associated with this instance of the XMLParser
`javax.xml.parsers.SAXParser` `getParser()` Return the SAXParser we will use to parse the input stream.
`org.xml.sax.XMLReader` `getReader()` Deprecated. Use getXMLReader() instead, which can throw a SAXException if the reader cannot be instantiated
`ScriptBlock` `getScript()` Returns the script that has just been created if this class is used as a SAX ContentHandler and passed into some XML processor or parser.
`boolean` `getUseContextClassLoader()` Return the boolean as to whether the context classloader should be used.
`boolean` `getValidating()` Return the validating parser flag.
`org.xml.sax.XMLReader` `getXMLReader()` Return the XMLReader to be used for parsing the input document.
`void` `ignorableWhitespace(char[] buffer, int start, int len)` Process notification of ignorable whitespace received from the body of an XML element.
`boolean` `isEscapeByDefault()`
`void` `notationDecl(java.lang.String name, java.lang.String publicId, java.lang.String systemId)` Receive notification of a notation declaration event.
`Script` `parse(java.io.File file)` Parse the content of the specified file using this XMLParser.
`Script` `parse(org.xml.sax.InputSource input)` Parse the content of the specified input source using this XMLParser.
`Script` `parse(java.io.InputStream input)` Parse the content of the specified input stream using this XMLParser.
`Script` `parse(java.io.Reader reader)` Parse the content of the specified reader using this XMLParser.
`Script` `parse(java.lang.String uri)` Parse the content of the specified URI using this XMLParser.
`Script` `parse(java.net.URL url)` Parse the content of the specified file using this XMLParser.
`void` `processingInstruction(java.lang.String target, java.lang.String data)` Process notification of a processing instruction that was encountered.
`void` `setClassLoader(java.lang.ClassLoader classLoader)` Set the class loader to be used for instantiating application objects when required.
`void` `setContext(JellyContext context)`
`void` `setDefaultNamespaceURI(java.lang.String namespace)` Set the jelly namespace to use for unprefixed elements.
`void` `setDocumentLocator(org.xml.sax.Locator locator)` Set the document locator associated with our parser.
`void` `setErrorHandler(org.xml.sax.ErrorHandler errorHandler)` Set the error handler for this XMLParser.
`void` `setEscapeByDefault(boolean escapeByDefault)`
`void` `setExpressionFactory(ExpressionFactory expressionFactory)` Sets the expression factory used to evaluate tag attributes
`void` `setLogger(org.apache.commons.logging.Log log)` Set the current logger for this XMLParser.
`void` `setUseContextClassLoader(boolean use)` Determine whether to use the Context ClassLoader (the one found by calling `Thread.currentThread().getContextClassLoader()`) to resolve/load classes.
`void` `setValidating(boolean validating)` Set the validating parser flag.
`void` `skippedEntity(java.lang.String name)` Process notification of a skipped entity.
`void` `startDocument()` Process notification of the beginning of the document being reached.
`void` `startElement(java.lang.String namespaceURI, java.lang.String localName, java.lang.String qName, org.xml.sax.Attributes list)` Process notification of the start of an XML element being reached.
`void` `startPrefixMapping(java.lang.String prefix, java.lang.String namespaceURI)` Process notification that a namespace prefix is coming in to scope.
`void` `unparsedEntityDecl(java.lang.String name, java.lang.String publicId, java.lang.String systemId, java.lang.String notation)` Receive notification of an unparsed entity declaration event.
`void` `warning(SAXParseException exception)` Forward notification of a parse warning to the application supplied error handler (if any).

### Methods inherited from class org.xml.sax.helpers.DefaultHandler

`error, fatalError, resolveEntity, warning`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### classLoader

    protected java.lang.ClassLoader classLoader

The class loader to use for instantiating application objects. If not specified, the context class loader, or the class loader used to load XMLParser itself, is used, based on the value of the `useContextClassLoader` variable.

#### useContextClassLoader

    protected boolean useContextClassLoader

Do we want to use the Context ClassLoader when loading classes for instantiating new objects? Default is `false`.

#### errorHandler

    protected org.xml.sax.ErrorHandler errorHandler

The application-supplied error handler that is notified when parsing warnings, errors, or fatal errors occur.

#### factory

    protected static javax.xml.parsers.SAXParserFactory factory

The SAXParserFactory that is created the first time we need it.

#### parser

    protected javax.xml.parsers.SAXParser parser

The SAXParser we will use to parse the input stream.

#### reader

    protected org.xml.sax.XMLReader reader

The XMLReader used to parse digester rules.

#### locator

    protected org.xml.sax.Locator locator

The Locator associated with our parser.

#### namespaces

    protected java.util.Map namespaces

Registered namespaces we are currently processing. The key is the namespace prefix that was declared in the document. The value is an ArrayStack of the namespace URIs this prefix has been mapped to -- the top Stack element is the most current one. (This architecture is required because documents can declare nested uses of the same prefix for different Namespace URIs).

#### validating

    protected boolean validating

Do we want to use a validating parser?

### Constructor Detail

#### XMLParser

    public XMLParser()

Construct a new XMLParser with default properties.

#### XMLParser

    public XMLParser(javax.xml.parsers.SAXParser parser)

Construct a new XMLParser, allowing a SAXParser to be passed in. This allows XMLParser to be used in environments which are unfriendly to JAXP1.1 (such as WebLogic 6.0). Thanks for the request to change go to James House (james@interobjective.com). This may help in places where you are able to load JAXP 1.1 classes yourself.

#### XMLParser

    public XMLParser(org.xml.sax.XMLReader reader)

Construct a new XMLParser, allowing an XMLReader to be passed in. This allows XMLParser to be used in environments which are unfriendly to JAXP1.1 (such as WebLogic 6.0). Note that if you use this option you have to configure namespace and validation support yourself, as these properties only affect the SAXParser and emtpy constructor.

### Method Detail

#### setEscapeByDefault

    public void setEscapeByDefault(boolean escapeByDefault)

#### isEscapeByDefault

    public boolean isEscapeByDefault()

#### parse

    public Script parse(java.io.File file)
                 throws java.io.IOException,
                        org.xml.sax.SAXException

Parse the content of the specified file using this XMLParser. Returns the root element from the object stack (if any).

Parameters:
  `file` - File containing the XML data to be parsed
Throws:
  `java.io.IOException` - if an input/output error occurs
  `org.xml.sax.SAXException` - if a parsing exception occurs

#### parse

    public Script parse(java.net.URL url)
                 throws java.io.IOException,
                        org.xml.sax.SAXException

Parse the content of the specified file using this XMLParser. Returns the root element from the object stack (if any).

Parameters:
  `url` - URL containing the XML data to be parsed
Throws:
  `java.io.IOException` - if an input/output error occurs
  `org.xml.sax.SAXException` - if a parsing exception occurs

#### parse

    public Script parse(org.xml.sax.InputSource input)
                 throws java.io.IOException,
                        org.xml.sax.SAXException

Parse the content of the specified input source using this XMLParser. Returns the root element from the object stack (if any).

Parameters:
  `input` - Input source containing the XML data to be parsed
Throws:
  `java.io.IOException` - if an input/output error occurs
  `org.xml.sax.SAXException` - if a parsing exception occurs

#### parse

    public Script parse(java.io.InputStream input)
                 throws java.io.IOException,
                        org.xml.sax.SAXException

Parse the content of the specified input stream using this XMLParser. Returns the root element from the object stack (if any). (Note: if reading a File or URL, use one of the URL-based parse methods instead. This method will not be able to resolve any relative paths inside a DTD.)

Parameters:
  `input` - Input stream containing the XML data to be parsed
Returns:
Throws:
  `java.io.IOException` - if an input/output error occurs
  `org.xml.sax.SAXException` - if a parsing exception occurs

#### parse

    public Script parse(java.io.Reader reader)
                 throws java.io.IOException,
                        org.xml.sax.SAXException

Parse the content of the specified reader using this XMLParser. Returns the root element from the object stack (if any). (Note: if reading a File or URL, use one of the URL-based parse methods instead. This method will not be able to resolve any relative paths inside a DTD.)

Parameters:
  `reader` - Reader containing the XML data to be parsed
Returns:
Throws:
  `java.io.IOException` - if an input/output error occurs
  `org.xml.sax.SAXException` - if a parsing exception occurs

#### parse

    public Script parse(java.lang.String uri)
                 throws java.io.IOException,
                        org.xml.sax.SAXException

Parse the content of the specified URI using this XMLParser. Returns the root element from the object stack (if any).

Parameters:
  `uri` - URI containing the XML data to be parsed
Throws:
  `java.io.IOException` - if an input/output error occurs
  `org.xml.sax.SAXException` - if a parsing exception occurs

#### findNamespaceURI

    public java.lang.String findNamespaceURI(java.lang.String prefix)

Return the currently mapped namespace URI for the specified prefix, if any; otherwise return `null`. These mappings come and go dynamically as the document is parsed.

Parameters:
  `prefix` - Prefix to look up

#### getContext

    public JellyContext getContext()

#### setContext

    public void setContext(JellyContext context)

#### setDefaultNamespaceURI

    public void setDefaultNamespaceURI(java.lang.String namespace)

Set the jelly namespace to use for unprefixed elements. Will be overridden by an explicit namespace in the XML document.

Parameters:
  `namespace` - jelly namespace to use (e.g. 'jelly:core')

#### getClassLoader

    public java.lang.ClassLoader getClassLoader()

Return the class loader to be used for instantiating application objects when required. This is determined based upon the following rules:

- The class loader set by `setClassLoader()`, if any
- The thread context class loader, if it exists and the `useContextClassLoader` property is set to true
- The class loader used to load the XMLParser class itself.

#### setClassLoader

    public void setClassLoader(java.lang.ClassLoader classLoader)

Set the class loader to be used for instantiating application objects when required.

Parameters:
  `classLoader` - The new class loader to use, or `null` to revert to the standard rules

#### getUseContextClassLoader

    public boolean getUseContextClassLoader()

Return the boolean as to whether the context classloader should be used.

#### setUseContextClassLoader

    public void setUseContextClassLoader(boolean use)

Determine whether to use the Context ClassLoader (the one found by calling `Thread.currentThread().getContextClassLoader()`) to resolve/load classes. If not using Context ClassLoader, then the class-loading defaults to using the calling-class' ClassLoader.

Parameters:
  `use` - determines whether to use JellyContext ClassLoader.

#### getErrorHandler

    public org.xml.sax.ErrorHandler getErrorHandler()

Return the error handler for this XMLParser.

#### setErrorHandler

    public void setErrorHandler(org.xml.sax.ErrorHandler errorHandler)

Set the error handler for this XMLParser.

Parameters:
  `errorHandler` - The new error handler

#### getLogger

    public org.apache.commons.logging.Log getLogger()

Return the current Logger associated with this instance of the XMLParser

#### setLogger

    public void setLogger(org.apache.commons.logging.Log log)

Set the current logger for this XMLParser.

#### getExpressionFactory

    public ExpressionFactory getExpressionFactory()

Returns:
  the expression factory used to evaluate tag attributes

#### setExpressionFactory

    public void setExpressionFactory(ExpressionFactory expressionFactory)

Sets the expression factory used to evaluate tag attributes

#### getParser

    public javax.xml.parsers.SAXParser getParser()

Return the SAXParser we will use to parse the input stream. If there is a problem creating the parser, return `null`.

#### getReader

    public org.xml.sax.XMLReader getReader()

Deprecated. Use getXMLReader() instead, which can throw a SAXException if the reader cannot be instantiated
By setting the reader in the constructor, you can bypass JAXP and be able to use digester in Weblogic 6.0.

#### getXMLReader

    public org.xml.sax.XMLReader getXMLReader()
                                       throws org.xml.sax.SAXException

Return the XMLReader to be used for parsing the input document.

Throws:
  `org.xml.sax.SAXException` - if no XMLReader can be instantiated

#### getValidating

    public boolean getValidating()

Return the validating parser flag.

#### setValidating

    public void setValidating(boolean validating)

Set the validating parser flag. This must be called before `parse()` is called the first time.

Parameters:
  `validating` - The new validating parser flag.

#### getScript

    public ScriptBlock getScript()

Returns the script that has just been created if this class is used as a SAX ContentHandler and passed into some XML processor or parser.

Returns:
  the ScriptBlock created if SAX events are piped into this class, which must include a startDocument() and endDocument()

#### startDocument

    public void startDocument()
                       throws org.xml.sax.SAXException

Process notification of the beginning of the document being reached.

Specified by:
  `startDocument` in interface `org.xml.sax.ContentHandler`
Overrides:
  `startDocument` in class `org.xml.sax.helpers.DefaultHandler`
Throws:
  `org.xml.sax.SAXException` - if a parsing error is to be reported

#### endDocument

    public void endDocument()
                     throws org.xml.sax.SAXException

Process notification of the end of the document being reached.

Specified by:
  `endDocument` in interface `org.xml.sax.ContentHandler`
Overrides:
  `endDocument` in class `org.xml.sax.helpers.DefaultHandler`
Throws:
  `org.xml.sax.SAXException` - if a parsing error is to be reported

#### startElement

    public void startElement(java.lang.String namespaceURI,
                    java.lang.String localName,
                    java.lang.String qName,
                    org.xml.sax.Attributes list)
                      throws org.xml.sax.SAXException

Process notification of the start of an XML element being reached.

Specified by:
  `startElement` in interface `org.xml.sax.ContentHandler`
Overrides:
  `startElement` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `namespaceURI` - The Namespace URI, or the empty string if the element has no Namespace URI or if Namespace processing is not being performed.
  `localName` - The local name (without prefix), or the empty string if Namespace processing is not being performed.
  `qName` - The qualified name (with prefix), or the empty string if qualified names are not available.\
  `list` - The attributes attached to the element. If there are no attributes, it shall be an empty Attributes object.
Throws:
  `org.xml.sax.SAXException` - if a parsing error is to be reported

#### characters

    public void characters(char[] buffer,
                  int start,
                  int length)
                    throws org.xml.sax.SAXException

Process notification of character data received from the body of an XML element.

Specified by:
  `characters` in interface `org.xml.sax.ContentHandler`
Overrides:
  `characters` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `buffer` - The characters from the XML document
  `start` - Starting offset into the buffer
  `length` - Number of characters from the buffer
Throws:
  `org.xml.sax.SAXException` - if a parsing error is to be reported

#### endElement

    public void endElement(java.lang.String namespaceURI,
                  java.lang.String localName,
                  java.lang.String qName)
                    throws org.xml.sax.SAXException

Process notification of the end of an XML element being reached.

Specified by:
  `endElement` in interface `org.xml.sax.ContentHandler`
Overrides:
  `endElement` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `namespaceURI` - The Namespace URI, or the empty string if the element has no Namespace URI or if Namespace processing is not being performed.
  `localName` - The local name (without prefix), or the empty string if Namespace processing is not being performed.
  `qName` - The qualified XML 1.0 name (with prefix), or the empty string if qualified names are not available.
Throws:
  `org.xml.sax.SAXException` - if a parsing error is to be reported

#### startPrefixMapping

    public void startPrefixMapping(java.lang.String prefix,
                          java.lang.String namespaceURI)
                            throws org.xml.sax.SAXException

Process notification that a namespace prefix is coming in to scope.

Specified by:
  `startPrefixMapping` in interface `org.xml.sax.ContentHandler`
Overrides:
  `startPrefixMapping` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `prefix` - Prefix that is being declared
  `namespaceURI` - Corresponding namespace URI being mapped to
Throws:
  `org.xml.sax.SAXException` - if a parsing error is to be reported

#### endPrefixMapping

    public void endPrefixMapping(java.lang.String prefix)
                          throws org.xml.sax.SAXException

Process notification that a namespace prefix is going out of scope.

Specified by:
  `endPrefixMapping` in interface `org.xml.sax.ContentHandler`
Overrides:
  `endPrefixMapping` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `prefix` - Prefix that is going out of scope
Throws:
  `org.xml.sax.SAXException` - if a parsing error is to be reported

#### ignorableWhitespace

    public void ignorableWhitespace(char[] buffer,
                           int start,
                           int len)
                             throws org.xml.sax.SAXException

Process notification of ignorable whitespace received from the body of an XML element.

Specified by:
  `ignorableWhitespace` in interface `org.xml.sax.ContentHandler`
Overrides:
  `ignorableWhitespace` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `buffer` - The characters from the XML document
  `start` - Starting offset into the buffer
  `len` - Number of characters from the buffer
Throws:
  `org.xml.sax.SAXException` - if a parsing error is to be reported

#### processingInstruction

    public void processingInstruction(java.lang.String target,
                             java.lang.String data)
                               throws org.xml.sax.SAXException

Process notification of a processing instruction that was encountered.

Specified by:
  `processingInstruction` in interface `org.xml.sax.ContentHandler`
Overrides:
  `processingInstruction` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `target` - The processing instruction target
  `data` - The processing instruction data (if any)
Throws:
  `org.xml.sax.SAXException` - if a parsing error is to be reported

#### setDocumentLocator

    public void setDocumentLocator(org.xml.sax.Locator locator)

Set the document locator associated with our parser.

Specified by:
  `setDocumentLocator` in interface `org.xml.sax.ContentHandler`
Overrides:
  `setDocumentLocator` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `locator` - The new locator

#### skippedEntity

    public void skippedEntity(java.lang.String name)
                       throws org.xml.sax.SAXException

Process notification of a skipped entity.

Specified by:
  `skippedEntity` in interface `org.xml.sax.ContentHandler`
Overrides:
  `skippedEntity` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `name` - Name of the skipped entity
Throws:
  `org.xml.sax.SAXException` - if a parsing error is to be reported

#### notationDecl

    public void notationDecl(java.lang.String name,
                    java.lang.String publicId,
                    java.lang.String systemId)

Receive notification of a notation declaration event.

Specified by:
  `notationDecl` in interface `org.xml.sax.DTDHandler`
Overrides:
  `notationDecl` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `name` - The notation name
  `publicId` - The public identifier (if any)
  `systemId` - The system identifier (if any)

#### unparsedEntityDecl

    public void unparsedEntityDecl(java.lang.String name,
                          java.lang.String publicId,
                          java.lang.String systemId,
                          java.lang.String notation)

Receive notification of an unparsed entity declaration event.

Specified by:
  `unparsedEntityDecl` in interface `org.xml.sax.DTDHandler`
Overrides:
  `unparsedEntityDecl` in class `org.xml.sax.helpers.DefaultHandler`
Parameters:
  `name` - The unparsed entity name
  `publicId` - The public identifier (if any)
  `systemId` - The system identifier (if any)
  `notation` - The name of the associated notation

#### error

    public void error(SAXParseException exception)
               throws org.xml.sax.SAXException

Forward notification of a parsing error to the application supplied error handler, if any, otherwise throw a SAXException with the error.

Parameters:
  `exception` - The error information
Throws:
  `org.xml.sax.SAXException` - if a parsing exception occurs

#### fatalError

    public void fatalError(SAXParseException exception)
                    throws org.xml.sax.SAXException

Forward notification of a fatal parsing error to the application supplied error handler, if any, otherwise throw a SAXException with the error.

Parameters:
  `exception` - The fatal error information
Throws:
  `org.xml.sax.SAXException` - if a parsing exception occurs

#### warning

    public void warning(SAXParseException exception)
                 throws org.xml.sax.SAXException

Forward notification of a parse warning to the application supplied error handler (if any). Unlike XMLParser.error(SAXParseException) and XMLParser.fatalError(SAXParseException), this implementation will NOT throw a SAXException by default if no error handler is supplied.

Parameters:
  `exception` - The warning information
Throws:
  `org.xml.sax.SAXException` - if a parsing exception occurs

#### configure

    protected void configure()

This method is called only once before parsing occurs which allows tag libraries to be registered and so forth

#### getJellyProperties

    protected java.util.Properties getJellyProperties()

A helper method which loads the static Jelly properties once on startup

#### createTag

    protected TagScript createTag(java.lang.String namespaceURI,
                      java.lang.String localName,
                      org.xml.sax.Attributes list)
                           throws org.xml.sax.SAXException

Factory method to create new Tag script for the given namespaceURI and name or return null if this is not a custom Tag.

Throws:
  `org.xml.sax.SAXException`

#### createStaticTag

    protected TagScript createStaticTag(java.lang.String namespaceURI,
                            java.lang.String localName,
                            java.lang.String qName,
                            org.xml.sax.Attributes list)
                                 throws org.xml.sax.SAXException

Factory method to create a static Tag that represents some static content.

Note that to if you use jelly:define taglib, these tags might turn out to be non-static during the runtime.

Throws:
  `org.xml.sax.SAXException`

#### configureStaticTagAttributes

    protected void configureStaticTagAttributes(TagScript script,
                                    org.xml.sax.Attributes list)
                                         throws JellyException

Throws:
  `JellyException`

#### configureTagScript

    protected void configureTagScript(TagScript aTagScript)

Configure a newly created TagScript instance before any Expressions are created

Parameters:
  `aTagScript` -

#### addTextScript

    protected void addTextScript(java.lang.String text,
                     boolean start)
                          throws JellyException

Adds the text to the current script block parsing any embedded expressions into ExpressionScript objects.

Parameters:
  `start` - If the text precedes a start element. Otherwise the text precedes an end element.
Throws:
  `JellyException`

#### addExpressionScript

    protected void addExpressionScript(ScriptBlock script,
                           Expression expression)

Adds the given Expression object to the current Script.

#### createEscapingExpression

    protected Expression createEscapingExpression(Expression expression)

#### createConstantExpression

    protected Expression createConstantExpression(java.lang.String tagName,
                                      java.lang.String attributeName,
                                      java.lang.String attributeValue)

#### createExpressionFactory

    protected ExpressionFactory createExpressionFactory()

#### getCurrentURI

    protected java.lang.String getCurrentURI()

Returns:
  the current context URI as a String or null if there is no current context defined on the JellyContext

#### createSAXException

    protected org.xml.sax.SAXException createSAXException(java.lang.String message,
                                              java.lang.Exception e)

Create a SAX exception which also understands about the location in the file where the exception occurs

Returns:
  the new exception

#### createSAXException

    protected org.xml.sax.SAXException createSAXException(java.lang.Exception e)

Create a SAX exception which also understands about the location in the digester file where the exception occurs

Returns:
  the new exception

#### createSAXException

    protected org.xml.sax.SAXException createSAXException(java.lang.String message)

Create a SAX exception which also understands about the location in the digester file where the exception occurs

Returns:
  the new exception