| /******************************************************************************* |
| * Copyright (c) 2000, 2006 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.core.internal.model; |
| |
| import java.util.*; |
| import javax.xml.parsers.SAXParserFactory; |
| import org.eclipse.core.internal.runtime.*; |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.core.runtime.model.*; |
| import org.eclipse.osgi.util.NLS; |
| import org.osgi.framework.ServiceReference; |
| import org.xml.sax.*; |
| import org.xml.sax.helpers.DefaultHandler; |
| |
| public class PluginParser extends DefaultHandler implements IModel { |
| |
| // concrete object factory |
| Factory factory; |
| |
| // File name for this plugin or fragment |
| // This to help with error reporting |
| String locationName = null; |
| |
| // Current State Information |
| Stack stateStack = new Stack(); |
| |
| // Current object stack (used to hold the current object we are |
| // populating in this plugin descriptor |
| Stack objectStack = new Stack(); |
| |
| Locator locator = null; |
| |
| // Valid States |
| private static final int IGNORED_ELEMENT_STATE = 0; |
| private static final int INITIAL_STATE = 1; |
| private static final int PLUGIN_STATE = 2; |
| private static final int PLUGIN_RUNTIME_STATE = 3; |
| private static final int PLUGIN_REQUIRES_STATE = 4; |
| private static final int PLUGIN_EXTENSION_POINT_STATE = 5; |
| private static final int PLUGIN_EXTENSION_STATE = 6; |
| private static final int RUNTIME_LIBRARY_STATE = 7; |
| private static final int LIBRARY_EXPORT_STATE = 8; |
| // private static final int LIBRARY_PACKAGES_STATE = 12; |
| private static final int PLUGIN_REQUIRES_IMPORT_STATE = 9; |
| private static final int CONFIGURATION_ELEMENT_STATE = 10; |
| private static final int FRAGMENT_STATE = 11; |
| |
| // Keep a group of vectors as a temporary scratch space. These |
| // vectors will be used to populate arrays in the plugin descriptor |
| // once processing of the XML file is complete. |
| private static final int EXTENSION_POINT_INDEX = 0; |
| private static final int EXTENSION_INDEX = 1; |
| private static final int LAST_INDEX = 1; |
| private Vector scratchVectors[] = new Vector[LAST_INDEX + 1]; |
| |
| private ServiceReference parserReference; |
| |
| public PluginParser(Factory factory) { |
| super(); |
| this.factory = factory; |
| } |
| |
| /** |
| * Receive a Locator object for document events. |
| * |
| * <p>By default, do nothing. Application writers may override this |
| * method in a subclass if they wish to store the locator for use |
| * with other document events.</p> |
| * |
| * @param locator A locator for all SAX document events. |
| * @see org.xml.sax.ContentHandler#setDocumentLocator |
| * @see org.xml.sax.Locator |
| */ |
| public void setDocumentLocator(Locator locator) { |
| this.locator = locator; |
| } |
| |
| public void characters(char[] ch, int start, int length) { |
| int state = ((Integer) stateStack.peek()).intValue(); |
| if (state != CONFIGURATION_ELEMENT_STATE) |
| return; |
| if (state == CONFIGURATION_ELEMENT_STATE) { |
| // Accept character data within an element, is when it is |
| // part of a configuration element (i.e. an element within an EXTENSION element |
| ConfigurationElementModel currentConfigElement = (ConfigurationElementModel) objectStack.peek(); |
| String value = new String(ch, start, length); |
| String oldValue = currentConfigElement.getValueAsIs(); |
| if (oldValue == null) { |
| if (value.trim().length() != 0) |
| currentConfigElement.setValue(value); |
| } else { |
| currentConfigElement.setValue(oldValue + value); |
| } |
| } |
| } |
| |
| public void endDocument() { |
| } |
| |
| public void endElement(String uri, String elementName, String qName) { |
| switch (((Integer) stateStack.peek()).intValue()) { |
| case IGNORED_ELEMENT_STATE : |
| stateStack.pop(); |
| break; |
| case INITIAL_STATE : |
| // shouldn't get here |
| internalError(NLS.bind(Messages.parse_internalStack, elementName)); |
| break; |
| case PLUGIN_STATE : |
| case FRAGMENT_STATE : |
| if (elementName.equals(PLUGIN) || elementName.equals(FRAGMENT)) { |
| stateStack.pop(); |
| PluginModel root = (PluginModel) objectStack.peek(); |
| |
| // Put the extension points into this plugin |
| Vector extPointVector = scratchVectors[EXTENSION_POINT_INDEX]; |
| if (extPointVector.size() > 0) { |
| root.setDeclaredExtensionPoints((ExtensionPointModel[]) extPointVector.toArray(new ExtensionPointModel[extPointVector.size()])); |
| scratchVectors[EXTENSION_POINT_INDEX].removeAllElements(); |
| } |
| |
| // Put the extensions into this plugin too |
| Vector extVector = scratchVectors[EXTENSION_INDEX]; |
| if (extVector.size() > 0) { |
| root.setDeclaredExtensions((ExtensionModel[]) extVector.toArray(new ExtensionModel[extVector.size()])); |
| scratchVectors[EXTENSION_INDEX].removeAllElements(); |
| } |
| } |
| break; |
| case PLUGIN_RUNTIME_STATE : |
| if (elementName.equals(RUNTIME)) { |
| stateStack.pop(); |
| // take the vector of library entries and put them into the plugin |
| // descriptor |
| Vector libVector = (Vector) objectStack.pop(); |
| if (libVector.size() > 0) { |
| PluginModel model = (PluginModel) objectStack.peek(); |
| model.setRuntime((LibraryModel[]) libVector.toArray(new LibraryModel[libVector.size()])); |
| } |
| } |
| break; |
| case PLUGIN_REQUIRES_STATE : |
| if (elementName.equals(PLUGIN_REQUIRES)) { |
| stateStack.pop(); |
| // take the vector of prerequisites and put them into the plugin |
| // descriptor |
| Vector importVector = (Vector) objectStack.pop(); |
| if (importVector.size() > 0) { |
| PluginModel parentDescriptor = (PluginModel) objectStack.peek(); |
| parentDescriptor.setRequires((PluginPrerequisiteModel[]) importVector.toArray(new PluginPrerequisiteModel[importVector.size()])); |
| } |
| } |
| break; |
| case PLUGIN_EXTENSION_POINT_STATE : |
| if (elementName.equals(EXTENSION_POINT)) { |
| stateStack.pop(); |
| } |
| break; |
| case PLUGIN_EXTENSION_STATE : |
| if (elementName.equals(EXTENSION)) { |
| stateStack.pop(); |
| // Finish up extension object |
| ExtensionModel currentExtension = (ExtensionModel) objectStack.pop(); |
| PluginModel parent = (PluginModel) objectStack.peek(); |
| currentExtension.setParent(parent); |
| scratchVectors[EXTENSION_INDEX].addElement(currentExtension); |
| } |
| break; |
| case RUNTIME_LIBRARY_STATE : |
| if (elementName.equals(LIBRARY)) { |
| LibraryModel curLibrary = (LibraryModel) objectStack.pop(); |
| // Clean up the exports for this library entry |
| Vector exportsVector = (Vector) objectStack.pop(); |
| if (exportsVector.size() > 0) { |
| curLibrary.setExports((String[]) exportsVector.toArray(new String[exportsVector.size()])); |
| } |
| |
| // Add this library element to the vector "runtime" on the stack |
| Vector libraryVector = (Vector) objectStack.peek(); |
| libraryVector.addElement(curLibrary); |
| stateStack.pop(); |
| } |
| break; |
| case LIBRARY_EXPORT_STATE : |
| if (elementName.equals(LIBRARY_EXPORT)) { |
| stateStack.pop(); |
| } |
| break; |
| case PLUGIN_REQUIRES_IMPORT_STATE : |
| if (elementName.equals(PLUGIN_REQUIRES_IMPORT)) { |
| stateStack.pop(); |
| } |
| break; |
| case CONFIGURATION_ELEMENT_STATE : |
| // We don't care what the element name was |
| stateStack.pop(); |
| // Now finish up the configuration element object |
| ConfigurationElementModel currentConfigElement = (ConfigurationElementModel) objectStack.pop(); |
| |
| String value = currentConfigElement.getValueAsIs(); |
| if (value != null) { |
| currentConfigElement.setValue(value.trim()); |
| } |
| |
| Object parent = objectStack.peek(); |
| currentConfigElement.setParent(parent); |
| if (((Integer) stateStack.peek()).intValue() == PLUGIN_EXTENSION_STATE) { |
| // Want to add this configuration element to the subelements of an extension |
| ConfigurationElementModel[] oldValues = (ConfigurationElementModel[]) ((ExtensionModel) parent).getSubElements(); |
| int size = (oldValues == null) ? 0 : oldValues.length; |
| ConfigurationElementModel[] newValues = new ConfigurationElementModel[size + 1]; |
| for (int i = 0; i < size; i++) { |
| newValues[i] = oldValues[i]; |
| } |
| newValues[size] = currentConfigElement; |
| ((ExtensionModel) parent).setSubElements(newValues); |
| } else { |
| ConfigurationElementModel[] oldValues = (ConfigurationElementModel[]) ((ConfigurationElementModel) parent).getSubElements(); |
| int size = (oldValues == null) ? 0 : oldValues.length; |
| ConfigurationElementModel[] newValues = new ConfigurationElementModel[size + 1]; |
| for (int i = 0; i < size; i++) { |
| newValues[i] = oldValues[i]; |
| } |
| newValues[size] = currentConfigElement; |
| ((ConfigurationElementModel) parent).setSubElements(newValues); |
| } |
| break; |
| } |
| } |
| |
| public void error(SAXParseException ex) { |
| logStatus(ex); |
| } |
| |
| public void fatalError(SAXParseException ex) throws SAXException { |
| logStatus(ex); |
| throw ex; |
| } |
| |
| public void handleExtensionPointState(String elementName, Attributes attributes) { |
| |
| // We ignore all elements under extension points (if there are any) |
| stateStack.push(new Integer(IGNORED_ELEMENT_STATE)); |
| internalError(NLS.bind(Messages.parse_unknownElement, EXTENSION_POINT, elementName)); |
| } |
| |
| public void handleExtensionState(String elementName, Attributes attributes) { |
| |
| // You need to change the state here even though we will be executing the same |
| // code for ExtensionState and ConfigurationElementState. We ignore the name |
| // of the element for ConfigurationElements. When we are wrapping up, we will |
| // want to add each configuration element object to the subElements vector of |
| // its parent configuration element object. However, the first configuration |
| // element object we created (the last one we pop off the stack) will need to |
| // be added to a vector in the extension object called _configuration. |
| stateStack.push(new Integer(CONFIGURATION_ELEMENT_STATE)); |
| |
| // create a new Configuration Element and push it onto the object stack |
| ConfigurationElementModel currentConfigurationElement = factory.createConfigurationElement(); |
| objectStack.push(currentConfigurationElement); |
| currentConfigurationElement.setName(elementName); |
| |
| // Processing the attributes of a configuration element involves creating |
| // a new configuration property for each attribute and populating the configuration |
| // property with the name/value pair of the attribute. Note there will be one |
| // configuration property for each attribute |
| parseConfigurationElementAttributes(attributes); |
| } |
| |
| public void handleInitialState(String elementName, Attributes attributes) { |
| if (elementName.equals(PLUGIN)) { |
| stateStack.push(new Integer(PLUGIN_STATE)); |
| parsePluginAttributes(attributes); |
| } else if (elementName.equals(FRAGMENT)) { |
| stateStack.push(new Integer(FRAGMENT_STATE)); |
| parseFragmentAttributes(attributes); |
| } else { |
| stateStack.push(new Integer(IGNORED_ELEMENT_STATE)); |
| internalError(NLS.bind(Messages.parse_unknownTopElement, elementName)); |
| } |
| } |
| |
| public void handleLibraryExportState(String elementName, Attributes attributes) { |
| |
| // All elements ignored. |
| stateStack.push(new Integer(IGNORED_ELEMENT_STATE)); |
| internalError(NLS.bind(Messages.parse_unknownElement, LIBRARY_EXPORT, elementName)); |
| } |
| |
| public void handleLibraryState(String elementName, Attributes attributes) { |
| if (elementName.equals(LIBRARY_EXPORT)) { |
| // Change State |
| stateStack.push(new Integer(LIBRARY_EXPORT_STATE)); |
| // The top element on the stack much be a library element |
| LibraryModel currentLib = (LibraryModel) objectStack.peek(); |
| |
| if (attributes == null) |
| return; |
| |
| String maskValue = null; |
| |
| // Process Attributes |
| int len = attributes.getLength(); |
| for (int i = 0; i < len; i++) { |
| String attrName = attributes.getLocalName(i); |
| String attrValue = attributes.getValue(i).trim(); |
| |
| if (attrName.equals(LIBRARY_EXPORT_MASK)) |
| maskValue = attrValue; |
| else |
| internalError(NLS.bind(Messages.parse_unknownAttribute, LIBRARY, attrName)); |
| } |
| |
| // set up mask tables |
| // pop off the library - already in currentLib |
| objectStack.pop(); |
| Vector exportMask = (Vector) objectStack.peek(); |
| // push library back on |
| objectStack.push(currentLib); |
| if ((maskValue != null) && (!exportMask.contains(maskValue))) |
| exportMask.addElement(maskValue); |
| return; |
| } |
| |
| if (elementName.equals(LIBRARY_PACKAGES)) { |
| LibraryModel currentLib = (LibraryModel) objectStack.peek(); |
| if (attributes == null) |
| return; |
| for (int i = 0; i < attributes.getLength(); i++) { |
| if (LIBRARY_PACKAGES_PREFIXES.equals(attributes.getLocalName(i))) { |
| String line = attributes.getValue(i); |
| String[] prefixes = getArrayFromList(line); |
| currentLib.setPackagePrefixes(prefixes); |
| } |
| } |
| return; |
| } |
| |
| // Any other element is invalid |
| stateStack.push(new Integer(IGNORED_ELEMENT_STATE)); |
| internalError(NLS.bind(Messages.parse_unknownElement, LIBRARY, elementName)); |
| return; |
| } |
| |
| /** |
| * convert a list of comma-separated tokens into an array |
| */ |
| protected static String[] getArrayFromList(String line) { |
| if (line == null || line.trim().length() == 0) |
| return null; |
| Vector list = new Vector(); |
| StringTokenizer tokens = new StringTokenizer(line, ","); //$NON-NLS-1$ |
| while (tokens.hasMoreTokens()) { |
| String token = tokens.nextToken().trim(); |
| if (token.length() != 0) |
| list.addElement(token); |
| } |
| return list.isEmpty() ? null : (String[]) list.toArray(new String[0]); |
| } |
| |
| public void handlePluginState(String elementName, Attributes attributes) { |
| |
| if (elementName.equals(RUNTIME)) { |
| // We should only have one Runtime element in a plugin or fragment |
| Object whatIsIt = objectStack.peek(); |
| if (((whatIsIt instanceof PluginDescriptorModel) && (((PluginDescriptorModel) objectStack.peek()).getRuntime() != null)) || ((whatIsIt instanceof PluginFragmentModel) && (((PluginFragmentModel) objectStack.peek()).getRuntime() != null))) { |
| // This is at least the 2nd Runtime element we have |
| // hit. Ignore it and give an error. |
| stateStack.push(new Integer(IGNORED_ELEMENT_STATE)); |
| return; |
| } |
| stateStack.push(new Integer(PLUGIN_RUNTIME_STATE)); |
| // Push a new vector to hold all the library entries |
| objectStack.push(new Vector()); |
| return; |
| } |
| if (elementName.equals(PLUGIN_REQUIRES)) { |
| stateStack.push(new Integer(PLUGIN_REQUIRES_STATE)); |
| // Push a new vector to hold all the prerequisites |
| objectStack.push(new Vector()); |
| parseRequiresAttributes(attributes); |
| return; |
| } |
| if (elementName.equals(EXTENSION_POINT)) { |
| stateStack.push(new Integer(PLUGIN_EXTENSION_POINT_STATE)); |
| parseExtensionPointAttributes(attributes); |
| return; |
| } |
| if (elementName.equals(EXTENSION)) { |
| stateStack.push(new Integer(PLUGIN_EXTENSION_STATE)); |
| parseExtensionAttributes(attributes); |
| return; |
| } |
| |
| // If we get to this point, the element name is one we don't currently accept. |
| // Set the state to indicate that this element will be ignored |
| stateStack.push(new Integer(IGNORED_ELEMENT_STATE)); |
| internalError(NLS.bind(Messages.parse_unknownElement, PLUGIN + " / " + FRAGMENT, elementName)); //$NON-NLS-1$ |
| } |
| |
| public void handleRequiresImportState(String elementName, Attributes attributes) { |
| |
| // All elements ignored. |
| stateStack.push(new Integer(IGNORED_ELEMENT_STATE)); |
| internalError(NLS.bind(Messages.parse_unknownElement, PLUGIN_REQUIRES_IMPORT, elementName)); |
| } |
| |
| public void handleRequiresState(String elementName, Attributes attributes) { |
| |
| if (elementName.equals(PLUGIN_REQUIRES_IMPORT)) { |
| parsePluginRequiresImport(attributes); |
| return; |
| } |
| // If we get to this point, the element name is one we don't currently accept. |
| // Set the state to indicate that this element will be ignored |
| stateStack.push(new Integer(IGNORED_ELEMENT_STATE)); |
| internalError(NLS.bind(Messages.parse_unknownElement, PLUGIN_REQUIRES, elementName)); |
| } |
| |
| public void handleRuntimeState(String elementName, Attributes attributes) { |
| |
| if (elementName.equals(LIBRARY)) { |
| // Change State |
| stateStack.push(new Integer(RUNTIME_LIBRARY_STATE)); |
| // Process library attributes |
| parseLibraryAttributes(attributes); |
| return; |
| } |
| // If we get to this point, the element name is one we don't currently accept. |
| // Set the state to indicate that this element will be ignored |
| stateStack.push(new Integer(IGNORED_ELEMENT_STATE)); |
| internalError(NLS.bind(Messages.parse_unknownElement, RUNTIME, elementName)); |
| } |
| |
| public void ignoreableWhitespace(char[] ch, int start, int length) { |
| } |
| |
| private void logStatus(SAXParseException ex) { |
| String name = ex.getSystemId(); |
| if (name == null) |
| name = locationName; |
| if (name == null) |
| name = ""; //$NON-NLS-1$ |
| else |
| name = name.substring(1 + name.lastIndexOf("/")); //$NON-NLS-1$ |
| |
| String msg; |
| if (name.equals("")) //$NON-NLS-1$ |
| msg = NLS.bind(Messages.parse_error, ex.getMessage()); |
| else |
| msg = NLS.bind(Messages.parse_errorNameLineColumn, (new String[] {name, Integer.toString(ex.getLineNumber()), Integer.toString(ex.getColumnNumber()), ex.getMessage()})); |
| factory.error(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, msg, ex)); |
| } |
| |
| synchronized public PluginModel parsePlugin(InputSource in) throws Exception { |
| SAXParserFactory factory = acquireXMLParsing(); |
| if (factory == null) |
| return null; // TODO we log an error |
| |
| try { |
| locationName = in.getSystemId(); |
| factory.setNamespaceAware(true); |
| factory.setNamespaceAware(true); |
| try { |
| factory.setFeature("http://xml.org/sax/features/string-interning", true); //$NON-NLS-1$ |
| } catch (SAXException se) { |
| // ignore; we can still operate without string-interning |
| } |
| factory.setValidating(false); |
| factory.newSAXParser().parse(in, this); |
| return (PluginModel) objectStack.pop(); |
| } finally { |
| releaseXMLParsing(); |
| } |
| } |
| |
| private SAXParserFactory acquireXMLParsing() { |
| parserReference = InternalPlatform.getDefault().getBundleContext().getServiceReference("javax.xml.parsers.SAXParserFactory"); //$NON-NLS-1$ |
| if (parserReference == null) |
| return null; |
| return (SAXParserFactory) InternalPlatform.getDefault().getBundleContext().getService(parserReference); |
| } |
| |
| private void releaseXMLParsing() { |
| if (parserReference != null) |
| InternalPlatform.getDefault().getBundleContext().ungetService(parserReference); |
| } |
| |
| public void parseConfigurationElementAttributes(Attributes attributes) { |
| |
| ConfigurationElementModel parentConfigurationElement = (ConfigurationElementModel) objectStack.peek(); |
| parentConfigurationElement.setStartLine(locator.getLineNumber()); |
| |
| Vector propVector = null; |
| |
| // process attributes |
| int len = (attributes != null) ? attributes.getLength() : 0; |
| if (len == 0) |
| return; |
| propVector = new Vector(); |
| |
| for (int i = 0; i < len; i++) { |
| String attrName = attributes.getLocalName(i); |
| String attrValue = attributes.getValue(i); |
| |
| ConfigurationPropertyModel currentConfigurationProperty = factory.createConfigurationProperty(); |
| currentConfigurationProperty.setName(attrName); |
| currentConfigurationProperty.setValue(attrValue); |
| propVector.addElement(currentConfigurationProperty); |
| } |
| parentConfigurationElement.setProperties((ConfigurationPropertyModel[]) propVector.toArray(new ConfigurationPropertyModel[propVector.size()])); |
| propVector = null; |
| } |
| |
| public void parseExtensionAttributes(Attributes attributes) { |
| |
| PluginModel parent = (PluginModel) objectStack.peek(); |
| ExtensionModel currentExtension = factory.createExtension(); |
| currentExtension.setStartLine(locator.getLineNumber()); |
| objectStack.push(currentExtension); |
| |
| // Process Attributes |
| int len = (attributes != null) ? attributes.getLength() : 0; |
| for (int i = 0; i < len; i++) { |
| String attrName = attributes.getLocalName(i); |
| String attrValue = attributes.getValue(i).trim(); |
| |
| if (attrName.equals(EXTENSION_NAME)) |
| currentExtension.setName(attrValue); |
| else if (attrName.equals(EXTENSION_ID)) |
| currentExtension.setId(attrValue); |
| else if (attrName.equals(EXTENSION_TARGET)) { |
| // check if point is specified as a simple or qualified name |
| String targetName; |
| if (attrValue.lastIndexOf('.') == -1) { |
| String baseId = parent instanceof PluginDescriptorModel ? parent.getId() : ((PluginFragmentModel) parent).getPlugin(); |
| targetName = baseId + "." + attrValue; //$NON-NLS-1$ |
| } else |
| targetName = attrValue; |
| currentExtension.setExtensionPoint(targetName); |
| } else |
| internalError(NLS.bind(Messages.parse_unknownAttribute, EXTENSION, attrName)); |
| } |
| } |
| |
| public void parseExtensionPointAttributes(Attributes attributes) { |
| |
| ExtensionPointModel currentExtPoint = factory.createExtensionPoint(); |
| currentExtPoint.setStartLine(locator.getLineNumber()); |
| |
| // Process Attributes |
| int len = (attributes != null) ? attributes.getLength() : 0; |
| for (int i = 0; i < len; i++) { |
| String attrName = attributes.getLocalName(i); |
| String attrValue = attributes.getValue(i).trim(); |
| |
| if (attrName.equals(EXTENSION_POINT_NAME)) |
| currentExtPoint.setName(attrValue); |
| else if (attrName.equals(EXTENSION_POINT_ID)) |
| currentExtPoint.setId(attrValue); |
| else if (attrName.equals(EXTENSION_POINT_SCHEMA)) |
| currentExtPoint.setSchema(attrValue); |
| else |
| internalError(NLS.bind(Messages.parse_unknownAttribute, EXTENSION_POINT, attrName)); |
| } |
| // currentExtPoint contains a pointer to the parent plugin descriptor. |
| PluginModel root = (PluginModel) objectStack.peek(); |
| currentExtPoint.setParent(root); |
| |
| // Now populate the vector just below us on the objectStack with this extension point |
| scratchVectors[EXTENSION_POINT_INDEX].addElement(currentExtPoint); |
| } |
| |
| public void parseFragmentAttributes(Attributes attributes) { |
| PluginFragmentModel current = factory.createPluginFragment(); |
| current.setStartLine(locator.getLineNumber()); |
| objectStack.push(current); |
| |
| // process attributes |
| int len = attributes.getLength(); |
| for (int i = 0; i < len; i++) { |
| String attrName = attributes.getLocalName(i); |
| String attrValue = attributes.getValue(i).trim(); |
| |
| if (attrName.equals(FRAGMENT_ID)) |
| current.setId(attrValue); |
| else if (attrName.equals(FRAGMENT_NAME)) |
| current.setName(attrValue); |
| else if (attrName.equals(FRAGMENT_VERSION)) |
| current.setVersion(attrValue); |
| else if (attrName.equals(FRAGMENT_PROVIDER)) |
| current.setProviderName(attrValue); |
| else if (attrName.equals(FRAGMENT_PLUGIN_ID)) |
| current.setPlugin(attrValue); |
| else if (attrName.equals(FRAGMENT_PLUGIN_VERSION)) |
| current.setPluginVersion(attrValue); |
| else if (attrName.equals(FRAGMENT_PLUGIN_MATCH)) { |
| if (FRAGMENT_PLUGIN_MATCH_PERFECT.equals(attrValue)) |
| current.setMatch(PluginFragmentModel.FRAGMENT_MATCH_PERFECT); |
| else if (FRAGMENT_PLUGIN_MATCH_EQUIVALENT.equals(attrValue)) |
| current.setMatch(PluginFragmentModel.FRAGMENT_MATCH_EQUIVALENT); |
| else if (FRAGMENT_PLUGIN_MATCH_COMPATIBLE.equals(attrValue)) |
| current.setMatch(PluginFragmentModel.FRAGMENT_MATCH_COMPATIBLE); |
| else if (FRAGMENT_PLUGIN_MATCH_GREATER_OR_EQUAL.equals(attrValue)) |
| current.setMatch(PluginFragmentModel.FRAGMENT_MATCH_GREATER_OR_EQUAL); |
| else |
| internalError(NLS.bind(Messages.parse_validMatch, attrValue)); |
| } else |
| internalError(NLS.bind(Messages.parse_unknownAttribute, FRAGMENT, attrName)); |
| } |
| } |
| |
| public void parseLibraryAttributes(Attributes attributes) { |
| // Push a vector to hold the export mask |
| objectStack.push(new Vector()); |
| LibraryModel current = factory.createLibrary(); |
| current.setStartLine(locator.getLineNumber()); |
| objectStack.push(current); |
| |
| // Now the objectStack should contain the following: |
| // plugin descriptor or fragment (bottom of the stack) |
| // vector to hold all the library entries |
| // vector to hold the export mask for this library entry |
| // this library entry (top of the stack) |
| |
| // process attributes |
| int len = (attributes != null) ? attributes.getLength() : 0; |
| for (int i = 0; i < len; i++) { |
| String attrName = attributes.getLocalName(i); |
| String attrValue = attributes.getValue(i).trim(); |
| |
| if (attrName.equals(LIBRARY_NAME)) |
| current.setName(attrValue); |
| else if (attrName.equals(LIBRARY_TYPE)) { |
| attrValue = attrValue.toLowerCase(); |
| if (attrValue.equals(LibraryModel.CODE) || attrValue.equals(LibraryModel.RESOURCE)) |
| current.setType(attrValue.toLowerCase()); |
| else |
| internalError(NLS.bind(Messages.parse_unknownLibraryType, attrValue, current.getName())); |
| } else |
| internalError(NLS.bind(Messages.parse_unknownAttribute, LIBRARY, attrName)); |
| } |
| } |
| |
| public void parsePluginAttributes(Attributes attributes) { |
| |
| PluginDescriptorModel current = factory.createPluginDescriptor(); |
| current.setStartLine(locator.getLineNumber()); |
| objectStack.push(current); |
| |
| // process attributes |
| int len = attributes.getLength(); |
| for (int i = 0; i < len; i++) { |
| String attrName = attributes.getLocalName(i); |
| String attrValue = attributes.getValue(i).trim(); |
| |
| if (attrName.equals(PLUGIN_ID)) |
| current.setId(attrValue); |
| else if (attrName.equals(PLUGIN_NAME)) |
| current.setName(attrValue); |
| else if (attrName.equals(PLUGIN_VERSION)) |
| current.setVersion(attrValue); |
| else if (attrName.equals(PLUGIN_VENDOR) || (attrName.equals(PLUGIN_PROVIDER))) |
| current.setProviderName(attrValue); |
| else if (attrName.equals(PLUGIN_CLASS)) |
| current.setPluginClass(attrValue); |
| else |
| internalError(NLS.bind(Messages.parse_unknownAttribute, PLUGIN, attrName)); |
| } |
| } |
| |
| public void parsePluginRequiresImport(Attributes attributes) { |
| PluginPrerequisiteModel current = factory.createPluginPrerequisite(); |
| current.setStartLine(locator.getLineNumber()); |
| |
| // process attributes |
| int len = (attributes != null) ? attributes.getLength() : 0; |
| for (int i = 0; i < len; i++) { |
| String attrName = attributes.getLocalName(i); |
| String attrValue = attributes.getValue(i).trim(); |
| |
| if (attrName.equals(PLUGIN_REQUIRES_PLUGIN)) |
| current.setPlugin(attrValue); |
| else if (attrName.equals(PLUGIN_REQUIRES_PLUGIN_VERSION)) |
| current.setVersion(attrValue); |
| else if (attrName.equals(PLUGIN_REQUIRES_OPTIONAL)) |
| current.setOptional(TRUE.equalsIgnoreCase(attrValue)); |
| else if (attrName.equals(PLUGIN_REQUIRES_MATCH)) { |
| if (PLUGIN_REQUIRES_MATCH_PERFECT.equals(attrValue)) |
| current.setMatchByte(PluginPrerequisiteModel.PREREQ_MATCH_PERFECT); |
| else if ((PLUGIN_REQUIRES_MATCH_EQUIVALENT.equals(attrValue)) || (PLUGIN_REQUIRES_MATCH_EXACT.equals(attrValue))) |
| current.setMatchByte(PluginPrerequisiteModel.PREREQ_MATCH_EQUIVALENT); |
| else if (PLUGIN_REQUIRES_MATCH_COMPATIBLE.equals(attrValue)) |
| current.setMatchByte(PluginPrerequisiteModel.PREREQ_MATCH_COMPATIBLE); |
| else if (PLUGIN_REQUIRES_MATCH_GREATER_OR_EQUAL.equals(attrValue)) |
| current.setMatchByte(PluginPrerequisiteModel.PREREQ_MATCH_GREATER_OR_EQUAL); |
| else |
| internalError(NLS.bind(Messages.parse_validMatch, attrValue)); |
| } else if (attrName.equals(PLUGIN_REQUIRES_EXPORT)) { |
| if (TRUE.equals(attrValue)) |
| current.setExport(true); |
| else if (FALSE.equals(attrValue)) |
| current.setExport(false); |
| else |
| internalError(NLS.bind(Messages.parse_validExport, attrValue)); |
| } else |
| internalError(NLS.bind(Messages.parse_unknownAttribute, PLUGIN_REQUIRES_IMPORT, attrName)); |
| |
| } |
| // Populate the vector of prerequisites with this new element |
| ((Vector) objectStack.peek()).addElement(current); |
| } |
| |
| public void parseRequiresAttributes(Attributes attributes) { |
| } |
| |
| static String replace(String s, String from, String to) { |
| String str = s; |
| int fromLen = from.length(); |
| int toLen = to.length(); |
| int ix = str.indexOf(from); |
| while (ix != -1) { |
| str = str.substring(0, ix) + to + str.substring(ix + fromLen); |
| ix = str.indexOf(from, ix + toLen); |
| } |
| return str; |
| } |
| |
| public void startDocument() { |
| stateStack.push(new Integer(INITIAL_STATE)); |
| for (int i = 0; i <= LAST_INDEX; i++) { |
| scratchVectors[i] = new Vector(); |
| } |
| } |
| |
| public void startElement(String uri, String elementName, String qName, Attributes attributes) { |
| switch (((Integer) stateStack.peek()).intValue()) { |
| case INITIAL_STATE : |
| handleInitialState(elementName, attributes); |
| break; |
| case FRAGMENT_STATE : |
| handlePluginState(elementName, attributes); |
| break; |
| case PLUGIN_STATE : |
| handlePluginState(elementName, attributes); |
| break; |
| case PLUGIN_RUNTIME_STATE : |
| handleRuntimeState(elementName, attributes); |
| break; |
| case PLUGIN_REQUIRES_STATE : |
| handleRequiresState(elementName, attributes); |
| break; |
| case PLUGIN_EXTENSION_POINT_STATE : |
| handleExtensionPointState(elementName, attributes); |
| break; |
| case PLUGIN_EXTENSION_STATE : |
| case CONFIGURATION_ELEMENT_STATE : |
| handleExtensionState(elementName, attributes); |
| break; |
| case RUNTIME_LIBRARY_STATE : |
| handleLibraryState(elementName, attributes); |
| break; |
| case LIBRARY_EXPORT_STATE : |
| handleLibraryExportState(elementName, attributes); |
| break; |
| case PLUGIN_REQUIRES_IMPORT_STATE : |
| handleRequiresImportState(elementName, attributes); |
| break; |
| default : |
| stateStack.push(new Integer(IGNORED_ELEMENT_STATE)); |
| internalError(NLS.bind(Messages.parse_unknownTopElement, elementName)); |
| } |
| } |
| |
| public void warning(SAXParseException ex) { |
| logStatus(ex); |
| } |
| |
| private void internalError(String message) { |
| if (locationName != null) |
| factory.error(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, locationName + ": " + message, null)); //$NON-NLS-1$ |
| else |
| factory.error(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, message, null)); |
| } |
| |
| } |
