| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * Copyright (c) 2001 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, if |
| * any, must include the following acknowlegement: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowlegement may appear in the software itself, |
| * if and wherever such third-party acknowlegements normally appear. |
| * |
| * 4. The names "The Jakarta Project", "Ant", and "Apache Software |
| * Foundation" must not be used to endorse or promote products derived |
| * from this software without prior written permission. For written |
| * permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache" |
| * nor may "Apache" appear in their names without prior written |
| * permission of the Apache Group. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| |
| package org.apache.ant.core.xml; |
| |
| import java.io.*; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.*; |
| import javax.xml.parsers.*; |
| import org.apache.ant.core.model.*; |
| import org.apache.ant.core.support.*; |
| import org.xml.sax.*; |
| import org.xml.sax.helpers.DefaultHandler; |
| |
| /** |
| * Parses a project from an XML source using a SAX Parser. |
| * |
| * @author <a href="mailto:conor@apache.org">Conor MacNeill</a> |
| */ |
| public class XMLProjectParser { |
| private Stack recursionCheck = new Stack(); |
| |
| /** |
| * The factory used to create SAX parsers. |
| */ |
| private SAXParserFactory parserFactory; |
| |
| static private Location getLocation(Locator locator) { |
| return new Location(locator.getSystemId(), locator.getLineNumber(), |
| locator.getColumnNumber()); |
| } |
| |
| /** |
| * Parse a build file form the given URL. |
| * |
| * @param buildSource the URL from where the build source may be read. |
| * |
| * @throws SAXParseException if there is a problem parsing the build file. |
| */ |
| public Project parseBuildFile(URL buildSource) |
| throws ConfigException { |
| try { |
| parserFactory = SAXParserFactory.newInstance(); |
| SAXParser saxParser = parserFactory.newSAXParser(); |
| XMLReader xmlReader = saxParser.getXMLReader(); |
| |
| recursionCheck.push(buildSource); |
| ProjectRootHandler projectRootHandler |
| = new ProjectRootHandler(buildSource, xmlReader); |
| saxParser.parse(buildSource.toString(), projectRootHandler); |
| return projectRootHandler.getProject(); |
| } |
| catch (SAXParseException e) { |
| throw new ConfigException(e.getMessage(), e, |
| new Location(buildSource.toString(), |
| e.getLineNumber(), e.getColumnNumber())); |
| } |
| catch (NoProjectReadException e) { |
| throw new ConfigException("No project defined in build source", e, |
| new Location(buildSource.toString())); |
| } |
| catch (ParserConfigurationException e) { |
| throw new ConfigException("Unable to parse project: " + e.getMessage(), e, |
| new Location(buildSource.toString())); |
| } |
| catch (SAXException e) { |
| throw new ConfigException("Unable to parse project: " + e.getMessage(), e, |
| new Location(buildSource.toString())); |
| } |
| catch (IOException e) { |
| throw new ConfigException("Unable to parse project: " + e.getMessage(), e, |
| new Location(buildSource.toString())); |
| } |
| } |
| |
| /** |
| * The root handler handles the start of parsing. This element looks for the |
| * root element which must be a project element. It then delegates handling of the |
| * project element to a project handler from which it extracts the parsed project. |
| */ |
| private class ProjectRootHandler extends RootHandler { |
| /** |
| * The project handler created to parse the project element. |
| */ |
| ProjectHandler projectHandler; |
| |
| /** |
| * Create a Root Handler. |
| * |
| * @param buildSource the URL containing the build definition |
| * @param reader the XML parser. |
| */ |
| public ProjectRootHandler(URL buildSource, XMLReader reader) { |
| super(buildSource, reader); |
| } |
| |
| /** |
| * Start a new element in the root. This must be a project element |
| * All other elements are invalid. |
| * |
| * @param uri The Namespace URI. |
| * @param localName The local name (without prefix). |
| * @param qualifiedName The qualified name (with prefix) |
| * @param attributes The attributes attached to the element. |
| * |
| * @throws SAXParseException if there is a parsing problem. |
| */ |
| public void startElement(String uri, String localName, String qualifiedName, |
| Attributes attributes) throws SAXParseException { |
| if (qualifiedName.equals("project")) { |
| projectHandler = new ProjectHandler(getXMLReader(), this, |
| getLocator(), attributes, getSourceURL()); |
| } else { |
| throw new SAXParseException("Build file should start with a <project> element not <" + |
| qualifiedName + ">", getLocator()); |
| } |
| } |
| |
| /** |
| * Get the project that has been parsed from the element |
| * |
| * @return the project that has been parsed from the build osurce |
| * |
| * @throws NoProjectReadException thrown if no project was read in. |
| */ |
| public Project getProject() throws NoProjectReadException { |
| if (projectHandler == null) { |
| throw new NoProjectReadException(); |
| } |
| return projectHandler.getProject(); |
| } |
| } |
| |
| /** |
| * Root Handler for include elements. |
| * |
| * Includes must contain either a project (which is being extended) or |
| * a fragment element which contains the fragment to be included. |
| */ |
| private class IncludeRootHandler extends RootHandler { |
| /** |
| * The project into which the fragment is to be included. |
| */ |
| private Project project; |
| |
| /** |
| * Create an Include Root Handler. |
| * |
| * @param buildSource the URL containing the fragment definition |
| * @param reader the XML parser. |
| * @param project the project into which the fragment's elements will be included. |
| */ |
| public IncludeRootHandler(URL buildSource, XMLReader reader, Project project) { |
| super(buildSource, reader); |
| this.project = project; |
| } |
| |
| /** |
| * Start a new element in the include root. This must be a project element |
| * or a fragment element. All other elements are invalid. |
| * |
| * @param uri The Namespace URI. |
| * @param localName The local name (without prefix). |
| * @param qualifiedName The qualified name (with prefix) |
| * @param attributes The attributes attached to the element. |
| * |
| * @throws SAXParseException if there is a parsing problem. |
| */ |
| public void startElement(String uri, String localName, String qualifiedName, |
| Attributes attributes) throws SAXParseException { |
| if (qualifiedName.equals("project") || |
| qualifiedName.equals("fragment")) { |
| // if it is a fragment, it must have no attributes |
| // any project attributes are ignored |
| if (qualifiedName.equals("fragment") && attributes.getLength() != 0) { |
| throw new SAXParseException("<fragment> element may not have any attributes", |
| getLocator()); |
| } |
| new ProjectHandler(getXMLReader(), this, getLocator(), |
| getSourceURL(), project); |
| } else { |
| throw new SAXParseException("An included file should contain either a " + |
| "<project> or <fragment> element and not a <" + |
| qualifiedName + "> element", getLocator()); |
| } |
| } |
| } |
| |
| /** |
| * Element to parse the project element. |
| * |
| * The project handler creates a number of different handlers to which it |
| * delegates processing of child elements. |
| */ |
| private class ProjectHandler extends ElementHandler { |
| /** |
| * The project being parsed. |
| */ |
| private Project project; |
| |
| /** |
| * The sourceURL for the current content being added to the project. |
| */ |
| private URL sourceURL; |
| |
| /** |
| * Create a ProjectHandler to read in a complete project. |
| * |
| * @param xmlReader the XML parser being used to parse the project element. |
| * @param parent the parent element handler. |
| * @param locator the SAX locator object used to associate elements with source |
| * locations. |
| * @param attributes the project element's attributes. |
| * @param projectSource the URL from which the XML source is being parsed. |
| */ |
| public ProjectHandler(XMLReader xmlReader, ContentHandler parent, |
| Locator locator, Attributes attributes, URL projectSource) |
| throws SAXParseException { |
| |
| super(xmlReader, parent, locator); |
| this.sourceURL = projectSource; |
| project = new Project(projectSource, getLocation(locator)); |
| |
| String base = null; |
| String defaultTarget = null; |
| String projectName = null; |
| |
| Map aspects = new HashMap(); |
| for (int i = 0; i < attributes.getLength(); ++i) { |
| String attributeName = attributes.getQName(i); |
| String attributeValue = attributes.getValue(i); |
| if (attributeName.equals("base")) { |
| base = attributeValue; |
| } |
| else if (attributeName.equals("default")) { |
| defaultTarget = attributeValue; |
| } |
| else if (attributeName.equals("name")) { |
| projectName = attributeValue; |
| } |
| else if (attributeName.indexOf(":") != -1) { |
| // potential aspect attribute |
| aspects.put(attributeName, attributeValue); |
| } |
| else { |
| throw new SAXParseException("The attribute '" + attributeName + "' is not " + |
| "supported by the <project> element", getLocator()); |
| } |
| } |
| |
| project.setDefaultTarget(defaultTarget); |
| project.setBase(base); |
| project.setName(projectName); |
| project.setAspects(aspects); |
| } |
| |
| /** |
| * Create a Project handler for an included fragment. The elements |
| * from the fragment are added to the given project. |
| * |
| * @param xmlReader the XML parser being used to parse the project element. |
| * @param parent the parent element handler. |
| * @param locator the SAX locator object used to associate elements with source |
| * locations. |
| * @param includeSource the URL from which the XML source is being included. |
| * @param project the project to which the included fragments elements are added. |
| */ |
| public ProjectHandler(XMLReader xmlReader, ContentHandler parent, |
| Locator locator, URL includeSource, Project project) { |
| super(xmlReader, parent, locator); |
| this.sourceURL = includeSource; |
| this.project = project; |
| } |
| |
| /** |
| * Start a new element in the project. Project currently handle the |
| * following elements |
| * <ul> |
| * <li>import</li> |
| * <li>include</li> |
| * <li>target</li> |
| * </ul> |
| * |
| * Everything else is treated as a task. |
| * |
| * @param uri The Namespace URI. |
| * @param localName The local name (without prefix). |
| * @param qualifiedName The qualified name (with prefix) |
| * @param attributes The attributes attached to the element. |
| * |
| * @throws SAXParseException if there is a parsing problem. |
| */ |
| public void startElement(String uri, String localName, String qualifiedName, |
| Attributes attributes) throws SAXParseException { |
| if (qualifiedName.equals("import")) { |
| ImportHandler importHandler |
| = new ImportHandler(getXMLReader(), this, getLocator(), |
| attributes, sourceURL); |
| try { |
| project.importProject(importHandler.getImportName(), |
| importHandler.getImportedProject()); |
| } |
| catch (ProjectModelException e) { |
| throw new SAXParseException(e.getMessage(), getLocator(), e); |
| } |
| } |
| else if (qualifiedName.equals("include")) { |
| IncludeHandler includeHandler |
| = new IncludeHandler(getXMLReader(), this, getLocator(), |
| attributes, sourceURL, project); |
| } |
| else if (qualifiedName.equals("target")) { |
| TargetHandler targetHandler |
| = new TargetHandler(getXMLReader(), this, getLocator(), attributes); |
| try { |
| project.addTarget(targetHandler.getTarget()); |
| } |
| catch (ProjectModelException e) { |
| throw new SAXParseException(e.getMessage(), getLocator(), e); |
| } |
| } |
| else { |
| // everything else is a task |
| TaskElementHandler taskElementHandler |
| = new TaskElementHandler(getXMLReader(), this, getLocator(), |
| attributes, qualifiedName); |
| project.addTask(taskElementHandler.getTaskElement()); |
| } |
| } |
| |
| /** |
| * Get the project that has been parsed from the XML source |
| * |
| * @return the project model of the parsed project. |
| */ |
| public Project getProject() { |
| return project; |
| } |
| } |
| |
| /** |
| * The import handler handles the importing of one project into another. |
| * |
| * The project to be imported is parsed with a new parser and then added to the |
| * current project under the given import name |
| */ |
| private class ImportHandler extends ElementHandler { |
| /** |
| * The attribute used to name the import. |
| */ |
| static public final String IMPORT_NAME_ATTR = "name"; |
| |
| /** |
| * The attribute name used to locate the project to be imported. |
| */ |
| static public final String IMPORT_SYSTEMID_ATTR = "project"; |
| |
| /** |
| * The project that has been imported. |
| */ |
| private Project importedProject; |
| |
| /** |
| * The name under which the project is being imported. |
| */ |
| private String importName; |
| |
| /** |
| * The systemId (URL) where the project is to be imported from. |
| */ |
| private String projectSystemId; |
| |
| /** |
| * Create an import handler to import a project. |
| * |
| * @param xmlReader the XML parser being used to parse the import element. |
| * @param parent the parent element handler. |
| * @param locator the SAX locator object used to associate elements with source |
| * locations. |
| * @param attributes attributes of the import statement. |
| * @param importingSource the URL of the importing source. |
| */ |
| public ImportHandler(XMLReader xmlReader, ContentHandler parent, |
| Locator locator, Attributes attributes, URL importingSource) |
| throws SAXParseException { |
| super(xmlReader, parent, locator); |
| for (int i = 0; i < attributes.getLength(); ++i) { |
| String attributeName = attributes.getQName(i); |
| String attributeValue = attributes.getValue(i); |
| if (attributeName.equals(IMPORT_NAME_ATTR)) { |
| importName = attributeValue; |
| } |
| else if (attributeName.equals(IMPORT_SYSTEMID_ATTR)) { |
| projectSystemId = attributeValue; |
| } |
| else { |
| throw new SAXParseException("Attribute " + attributeName + |
| " is not allowed in an <import> element", getLocator()); |
| } |
| } |
| |
| if (importName == null) { |
| throw new SAXParseException("Attribute " + IMPORT_NAME_ATTR + |
| " is required in an <import> element", getLocator()); |
| } |
| |
| if (projectSystemId == null) { |
| throw new SAXParseException("Attribute " + IMPORT_SYSTEMID_ATTR + |
| " is required in an <import> element", getLocator()); |
| } |
| |
| // create a new parser to read this project relative to the |
| // project's URI |
| try { |
| URL importURL = new URL(importingSource, projectSystemId); |
| SAXParser importSAXParser = parserFactory.newSAXParser(); |
| XMLReader importXMLReader = importSAXParser.getXMLReader(); |
| |
| |
| if (recursionCheck.contains(importURL)) { |
| throw new SAXParseException("Circular import detected when importing '" + |
| importURL + "'", getLocator()); |
| } |
| recursionCheck.push(importURL); |
| ProjectRootHandler importRootHandler = new ProjectRootHandler(importURL, importXMLReader); |
| importSAXParser.parse(importURL.toString(), importRootHandler); |
| if (recursionCheck.pop() != importURL) { |
| throw new RuntimeException("Failure to pop expected element off recursion stack"); |
| } |
| importedProject = importRootHandler.getProject(); |
| } |
| catch (SAXParseException e) { |
| throw e; |
| } |
| catch (NoProjectReadException e) { |
| throw new SAXParseException("No project was imported from " + projectSystemId, |
| getLocator()); |
| } |
| catch (MalformedURLException e) { |
| throw new SAXParseException("Unable to import project from " + projectSystemId + |
| ": " + e.getMessage(), |
| getLocator()); |
| } |
| catch (ParserConfigurationException e) { |
| throw new SAXParseException("Unable to parse project imported from " + projectSystemId + |
| ": " + e.getMessage(), |
| getLocator()); |
| } |
| catch (SAXException e) { |
| throw new SAXParseException("Unable to parse project imported from " + projectSystemId + |
| ": " + e.getMessage(), |
| getLocator()); |
| } |
| catch (IOException e) { |
| throw new SAXParseException("Error reading project imported from " + projectSystemId + |
| ": " + e.getMessage(), |
| getLocator()); |
| } |
| } |
| |
| /** |
| * Import does not support nested elements. This method will always throw an |
| * exception |
| * @param uri The Namespace URI. |
| * @param localName The local name (without prefix). |
| * @param qualifiedName The qualified name (with prefix) |
| * @param attributes The attributes attached to the element. |
| * |
| * @throws SAXParseException always. |
| */ |
| public void startElement(String uri, String localName, String qualifiedName, |
| Attributes attributes) throws SAXParseException { |
| // everything is a task |
| throw new SAXParseException("<import> does not support nested elements", getLocator()); |
| } |
| |
| /** |
| * Get the project imported. |
| * |
| * @return an imported Project. |
| */ |
| public Project getImportedProject() { |
| return importedProject; |
| } |
| |
| /** |
| * Get the name under which the project is imported. |
| * |
| * @return the import name of the project |
| */ |
| public String getImportName() { |
| return importName; |
| } |
| } |
| |
| /** |
| * The include handler is used to read in included projects or |
| * fragments into a project. |
| */ |
| private class IncludeHandler extends ElementHandler { |
| /** |
| * The attribute name which identifies the fragment to be included |
| */ |
| static public final String INCLUDE_SYSTEMID_ATTR = "fragment"; |
| |
| /** |
| * The system id of the fragment to be included. |
| */ |
| private String includeSystemId; |
| |
| /** |
| * Create an IncludeHandler to include an element into the |
| * current project |
| * |
| * @param xmlReader the XML parser being used to parse the include element. |
| * @param parent the parent element handler. |
| * @param locator the SAX locator object used to associate elements with source |
| * locations. |
| * @param attributes attributes of the include statement. |
| * @param includingSource the URL of the including source. |
| * @param project the project into which the included elements are added. |
| */ |
| public IncludeHandler(XMLReader xmlReader, ContentHandler parent, |
| Locator locator, Attributes attributes, URL includingSource, |
| Project project) |
| throws SAXParseException { |
| super(xmlReader, parent, locator); |
| for (int i = 0; i < attributes.getLength(); ++i) { |
| String attributeName = attributes.getQName(i); |
| String attributeValue = attributes.getValue(i); |
| if (attributeName.equals(INCLUDE_SYSTEMID_ATTR)) { |
| includeSystemId = attributeValue; |
| } |
| else { |
| throw new SAXParseException("Attribute " + attributeName + |
| " is not allowed in an <include> element", getLocator()); |
| } |
| } |
| |
| if (includeSystemId == null) { |
| throw new SAXParseException("Attribute " + INCLUDE_SYSTEMID_ATTR + |
| " is required in an <include> element", getLocator()); |
| } |
| |
| // create a new parser to read this project relative to the |
| // project's URI |
| try { |
| URL includeURL = new URL(includingSource, includeSystemId); |
| SAXParser includeSAXParser = parserFactory.newSAXParser(); |
| XMLReader includeXMLReader = includeSAXParser.getXMLReader(); |
| |
| if (recursionCheck.contains(includeURL)) { |
| throw new SAXParseException("Circular include detected when including '" + |
| includeURL + "'", getLocator()); |
| } |
| recursionCheck.push(includeURL); |
| IncludeRootHandler includeRootHandler |
| = new IncludeRootHandler(includeURL, includeXMLReader, project); |
| includeSAXParser.parse(includeURL.toString(), includeRootHandler); |
| if (recursionCheck.pop() != includeURL) { |
| throw new RuntimeException("Failure to pop expected element off recursion stack"); |
| } |
| } |
| catch (SAXParseException e) { |
| throw e; |
| } |
| catch (MalformedURLException e) { |
| throw new SAXParseException("Unable to include " + includeSystemId + |
| ": " + e.getMessage(), |
| getLocator()); |
| } |
| catch (ParserConfigurationException e) { |
| throw new SAXParseException("Unable to parse include " + includeSystemId + |
| ": " + e.getMessage(), |
| getLocator()); |
| } |
| catch (SAXException e) { |
| throw new SAXParseException("Unable to parse include " + includeSystemId + |
| ": " + e.getMessage(), |
| getLocator()); |
| } |
| catch (IOException e) { |
| throw new SAXParseException("Error reading include " + includeSystemId + |
| ": " + e.getMessage(), |
| getLocator()); |
| } |
| } |
| |
| /** |
| * Include does not support nested elements. This method will always throw an |
| * exception |
| * |
| * @param uri The Namespace URI. |
| * @param localName The local name (without prefix). |
| * @param qualifiedName The qualified name (with prefix) |
| * @param attributes The attributes attached to the element. |
| * |
| * @throws SAXParseException always. |
| */ |
| public void startElement(String uri, String localName, String qualifiedName, |
| Attributes attributes) throws SAXParseException { |
| // everything is a task |
| throw new SAXParseException("<include> does not support nested elements", getLocator()); |
| } |
| |
| } |
| |
| /** |
| * A TargetHandler process the Target element. |
| */ |
| private class TargetHandler extends ElementHandler { |
| /** |
| * The target being configured. |
| */ |
| private Target target; |
| |
| /** |
| * Create a Target handler. Event element in a target is |
| * considered to be a task |
| * |
| * @param xmlReader the XML parser being used to parse the target element. |
| * @param parent the parent element handler. |
| * @param locator the SAX locator object used to associate elements with source |
| * locations. |
| * @param attributes attributes of the target |
| */ |
| public TargetHandler(XMLReader xmlReader, ContentHandler parent, |
| Locator locator, Attributes attributes) |
| throws SAXParseException { |
| super(xmlReader, parent, locator); |
| String targetName = null; |
| String depends = null; |
| Map aspects = new HashMap(); |
| for (int i = 0; i < attributes.getLength(); ++i) { |
| String attributeName = attributes.getQName(i); |
| String attributeValue = attributes.getValue(i); |
| if (attributeName.equals("name")) { |
| targetName = attributeValue; |
| } |
| else if (attributeName.equals("depends")) { |
| depends = attributeValue; |
| } |
| else if (attributeName.indexOf(":") != -1) { |
| // potential aspect attribute |
| aspects.put(attributeName, attributeValue); |
| } |
| else { |
| throw new SAXParseException("The attribute '" + attributeName + "' is not " + |
| "supported by the <target> element", getLocator()); |
| } |
| } |
| if (targetName == null) { |
| throw new SAXParseException("Targets must have a name attribute", locator); |
| } |
| target = new Target(getLocation(locator), targetName); |
| target.setAspects(aspects); |
| |
| if (depends != null) { |
| StringTokenizer tokenizer = new StringTokenizer(depends, ","); |
| while (tokenizer.hasMoreTokens()) { |
| String dependency = tokenizer.nextToken(); |
| target.addDependency(dependency); |
| } |
| } |
| } |
| |
| /* |
| * Process an element within this target. All elements within the target are |
| * treated as tasks. |
| * |
| * @param uri The Namespace URI. |
| * @param localName The local name (without prefix). |
| * @param qualifiedName The qualified name (with prefix) |
| * @param attributes The attributes attached to the element. |
| * |
| * @throws SAXParseException if there is a parsing problem. |
| */ |
| public void startElement(String uri, String localName, String qualifiedName, |
| Attributes attributes) throws SAXParseException { |
| // everything is a task |
| TaskElementHandler taskHandler |
| = new TaskElementHandler(getXMLReader(), this, getLocator(), |
| attributes, qualifiedName); |
| target.addTask(taskHandler.getTaskElement()); |
| } |
| |
| /** |
| * Get the target parsed by this handler. |
| * |
| * @return the Target model object parsed by this handler. |
| */ |
| public Target getTarget() { |
| return target; |
| } |
| } |
| |
| /** |
| * A TaskElementHandler parses the task elements of a build |
| */ |
| private class TaskElementHandler extends ElementHandler { |
| /** |
| * The task element being parsed by this handler. |
| */ |
| private TaskElement taskElement; |
| |
| /** |
| * Create a task element handler to parse a task element |
| * |
| * @param xmlReader the XML parser being used to parse the task element. |
| * @param parent the parent element handler. |
| * @param locator the SAX locator object used to associate elements with source |
| * locations. |
| * @param attributes attributes of the task element |
| * @param elementTagName the name of the task element. |
| */ |
| public TaskElementHandler(XMLReader xmlReader, ContentHandler parent, Locator locator, |
| Attributes attributes, String elementTagName) { |
| super(xmlReader, parent, locator); |
| taskElement |
| = new TaskElement(getLocation(locator), elementTagName); |
| |
| Map aspects = new HashMap(); |
| for (int i = 0; i < attributes.getLength(); ++i) { |
| String attributeName = attributes.getQName(i); |
| String attributeValue = attributes.getValue(i); |
| if (attributeName.indexOf(":") != -1) { |
| // potential aspect attribute |
| aspects.put(attributeName, attributeValue); |
| } |
| else { |
| taskElement.addAttribute(attributeName, attributeValue); |
| } |
| } |
| taskElement.setAspects(aspects); |
| } |
| |
| /** |
| * Process a nested element of this task element. All nested elements |
| * of a taskElement are themselves taskElements. |
| * |
| * @param uri The Namespace URI. |
| * @param localName The local name (without prefix). |
| * @param qualifiedName The qualified name (with prefix) |
| * @param attributes The attributes attached to the element. |
| * |
| * @throws SAXParseException if there is a parsing problem. |
| */ |
| public void startElement(String uri, String localName, String qualifiedName, |
| Attributes attributes) throws SAXParseException { |
| // everything within a task element is also a task element |
| TaskElementHandler nestedHandler |
| = new TaskElementHandler(getXMLReader(), this, getLocator(), |
| attributes, qualifiedName); |
| taskElement.addTaskElement(nestedHandler.getTaskElement()); |
| } |
| |
| public void characters(char[] buf, int start, int end) throws SAXParseException { |
| taskElement.addText(new String(buf, start, end)); |
| } |
| |
| /** |
| * Get the task element being parsed by this handler. |
| * |
| * @return the TaskElement being parsed. |
| */ |
| public TaskElement getTaskElement() { |
| return taskElement; |
| } |
| } |
| |
| /** |
| * A NoProjectReadException is used to indicate that a project |
| * was not read from the particular source. This will happen |
| * if the source is empty. |
| */ |
| private class NoProjectReadException extends Exception { |
| } |
| } |
| |
