| /******************************************************************************* |
| * Copyright (c) 2007 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: |
| * Hisashi MIYASHITA - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.actf.ai.xmlstore.nvdl.reader; |
| |
| import java.io.IOException; |
| |
| import javax.xml.parsers.ParserConfigurationException; |
| import javax.xml.parsers.SAXParser; |
| import javax.xml.parsers.SAXParserFactory; |
| import javax.xml.validation.SchemaFactory; |
| |
| import org.eclipse.actf.ai.xmlstore.nvdl.NVDLException; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.Location; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLAction; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLAllowAction; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLConst; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLMessage; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLMode; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLModel; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLModelException; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLRejectAction; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLResultAction; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLRule; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLRules; |
| import org.eclipse.actf.ai.xmlstore.nvdl.model.NVDLValidateAction; |
| import org.eclipse.actf.ai.xmlstore.nvdl.util.DefaultErrorHandler; |
| import org.eclipse.actf.ai.xmlstore.nvdl.util.Log; |
| import org.eclipse.actf.ai.xmlstore.nvdl.util.PrefixMapper; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.ErrorHandler; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXNotRecognizedException; |
| import org.xml.sax.SAXNotSupportedException; |
| import org.xml.sax.SAXParseException; |
| import org.xml.sax.XMLReader; |
| import org.xml.sax.helpers.DefaultHandler; |
| |
| |
| /** |
| * The <code>NVDLSAXReader</code> is a reader for NVDL scripts using SAX. |
| */ |
| public class NVDLSAXReader { |
| private NVDLRules rules; |
| |
| private ErrorHandler eh; |
| |
| private Locator locator; |
| |
| private int errorCounter; |
| |
| private Location newLocation() { |
| return new Location(locator.getLineNumber(), |
| locator.getColumnNumber(), |
| locator.getSystemId()); |
| } |
| |
| private void setLocation(NVDLModel m) { |
| m.setLocation(newLocation()); |
| } |
| |
| private XMLReader reader; |
| |
| private void error(NVDLReaderException e) throws SAXException { |
| if (eh != null) |
| eh.error(new SAXParseException(e.getMessage(), locator, e)); |
| } |
| |
| private void readUnknownError(String mes, Object[] args) throws SAXException { |
| errorCounter++; |
| error(new NVDLReaderException(mes, args)); |
| } |
| |
| private void readInvalidError(String mes) throws SAXException { |
| readInvalidError(mes, new Object[0]); |
| } |
| |
| private void readInvalidError(String mes, Object[] args) throws SAXException { |
| errorCounter++; |
| error(new NVDLReaderException(mes, args)); |
| } |
| |
| private boolean isForeign(String iri) { |
| return !NVDLConst.NVDL_NS.equals(iri); |
| } |
| |
| private boolean isLocal(String iri) { |
| return (iri.length() == 0); |
| } |
| |
| private static final String NSNAME = "xmlns"; |
| private boolean isNSDecl(String qName) { |
| if (!qName.startsWith(NSNAME)) return false; |
| if (qName.length() == NSNAME.length()) return true; |
| if (qName.charAt(NSNAME.length()) == ':') return true; |
| return false; |
| } |
| |
| private void setHandler(BaseHandler h) { |
| reader.setContentHandler(h); |
| } |
| |
| /* |
| Whitespace |
| */ |
| private StringBuffer removeLeadingAndTrailingSpaces(StringBuffer sb) { |
| int len = sb.length(); |
| int s, e; |
| ex1: for (s = 0; s < len; s++) { |
| char c = sb.charAt(s); |
| switch (c) { |
| case ' ': case '\r': case '\n': case '\t': |
| break; |
| default: |
| break ex1; |
| } |
| } |
| if (s == (len - 1)) { |
| sb.delete(0, s); |
| return sb; |
| } |
| ex2: for (e = len - 1; s >= 0; s--) { |
| char c = sb.charAt(e); |
| switch (c) { |
| case ' ': case '\r': case '\n': case '\t': |
| break; |
| default: |
| break ex2; |
| } |
| } |
| |
| if (s > 0) { |
| sb.delete(0, s); |
| } |
| if (e < (len - 1)) { |
| sb.delete(e, len - 1); |
| } |
| return sb; |
| } |
| |
| private String[] splitList(String s) { |
| return s.split("[ \r\n\t]"); |
| } |
| |
| private boolean checkWhiteSpace(char[] ch, int start, int length) { |
| for (int i = 0; i < length; i++) { |
| switch (ch[start + i]) { |
| case ' ': case '\r': case '\n': case '\t': |
| break; |
| default: |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /* |
| xsd:boolean |
| */ |
| |
| private boolean parseXSDBoolean(String s, boolean defaultValue) |
| throws SAXException { |
| if (s == null) return defaultValue; |
| StringBuffer sb = removeLeadingAndTrailingSpaces(new StringBuffer(s)); |
| String s2 = sb.toString(); |
| if (s2.equals("0")) return false; |
| if (s2.equals("false")) return false; |
| if (s2.equals("1")) return true; |
| if (s2.equals("true")) return true; |
| readInvalidError("NVDLReader.XSDBooleanError", new Object[] {s}); |
| return false; |
| } |
| |
| /* |
| Attribute |
| */ |
| static class AtRet { |
| String name; |
| String value; |
| AtRet(String name) { |
| this.name = name; |
| this.value = null; |
| } |
| } |
| |
| private void getAttrs(Attributes attr, AtRet[] ars) throws SAXException { |
| int len = attr.getLength(); |
| for (int i = 0; i < len; i++) { |
| String iri = attr.getURI(i); |
| if (!isLocal(iri)) continue; |
| String localName = attr.getLocalName(i); |
| String qName = attr.getQName(i); |
| if (isNSDecl(qName)) continue; |
| for (int j = 0; ; j++) { |
| if (j >= ars.length) { |
| readUnknownError("NVDLReader.UnallowedAttributeError", |
| new Object[] {localName}); |
| } |
| if (ars[j].name.equals(localName)) { |
| ars[j].value = attr.getValue(i); |
| break; |
| } |
| } |
| } |
| } |
| |
| private void checkAttrs(Attributes attr) throws SAXException { |
| int len = attr.getLength(); |
| for (int i = 0; i < len; i++) { |
| String iri = attr.getURI(i); |
| String localName = attr.getLocalName(i); |
| if (isLocal(iri)) { |
| readUnknownError("NVDLReader.UnallowedAttributeError", |
| new Object[] {localName}); |
| } |
| } |
| } |
| |
| /* |
| id |
| */ |
| |
| private String getXMLID(Attributes attrs) throws SAXException { |
| return attrs.getValue("id"); |
| } |
| |
| /* |
| Rule |
| */ |
| private void addRule(NVDLMode mode, NVDLRule rule) |
| throws SAXException { |
| NVDLRule conflictedRule = mode.addRule(rule); |
| if (conflictedRule != null) { |
| readInvalidError("NVDLReader.RuleConflictsError", |
| new Object[] {rule.toString(), conflictedRule.toString()}); |
| } |
| } |
| |
| /* |
| Mode Helper |
| */ |
| |
| private void checkNestedMode(NVDLAction action) throws SAXException { |
| if (action.getUseModeName() != null) { |
| readInvalidError("NVDLReader.NestedModeAndUseModeError"); |
| } |
| if (action.getUseMode() != null) { |
| readInvalidError("NVDLReader.DuplicatedNestedModeError"); |
| } |
| } |
| |
| private String uniqueModeName() { |
| StringBuffer name = new StringBuffer("mode-"); |
| name.append(locator.getLineNumber()); |
| name.append("-"); |
| name.append(locator.getColumnNumber()); |
| name.append("-"); |
| String fname; |
| for (int i = 1; ; i++) { |
| fname = name.toString() + i; |
| if (rules.getMode(fname) == null) break; |
| } |
| return fname; |
| } |
| |
| private String uniqueActionID(Attributes attrs) throws SAXException { |
| String id = getXMLID(attrs); |
| if ((id == null) || (id.length() == 0)) { |
| for (int i = 1; ; i++) { |
| id = "A" + i; |
| if (rules.getAction(id) == null) break; |
| } |
| } |
| return id; |
| } |
| |
| /* |
| PrefixMapper |
| */ |
| private PrefixMapper prefixMapper = new PrefixMapper(); |
| |
| /* |
| Handlers |
| */ |
| |
| private class BaseHandler extends DefaultHandler { |
| private final BaseHandler ph; |
| |
| public void startPrefixMapping(String prefix, |
| String uri) |
| throws SAXException { |
| prefixMapper.startPrefixMapping(prefix, uri); |
| } |
| |
| public void endPrefixMapping(String prefix) throws SAXException { |
| prefixMapper.endPrefixMapping(prefix); |
| } |
| |
| public void characters(char[] ch, int start, int length) |
| throws SAXException { |
| readUnknownError("NVDLReader.UnallowedCharactersError", |
| new Object[] {new String(ch, start, length)}); |
| } |
| |
| public void setDocumentLocator(Locator locator) { |
| NVDLSAXReader.this.locator = locator; |
| } |
| |
| public void startElement(String uri, |
| String localName, |
| String qName, |
| Attributes attributes) throws SAXException { |
| readUnknownError("NVDLReader.UnallowedElementError", |
| new Object[] {uri, qName}); |
| } |
| public void endElement(String uri, |
| String localName, |
| String qName) throws SAXException { |
| if (ph != null) setHandler(ph); |
| } |
| |
| BaseHandler(BaseHandler prev) { |
| this.ph = prev; |
| } |
| } |
| |
| private class ForeignSkipHandler extends BaseHandler { |
| private int level; |
| public void characters(char[] ch, int start, int length) |
| throws SAXException { |
| return; |
| } |
| public void startElement(String uri, |
| String localName, |
| String qName, |
| Attributes attributes) throws SAXException { |
| level++; |
| } |
| public void endElement(String uri, |
| String localName, |
| String qName) throws SAXException { |
| level--; |
| if (level <= 0) |
| super.endElement(uri, localName, qName); |
| } |
| ForeignSkipHandler(BaseHandler bh) { |
| super(bh); |
| level = 1; |
| } |
| } |
| |
| private class WSSkipHandler extends BaseHandler { |
| public void characters(char[] ch, int start, int length) |
| throws SAXException { |
| if (!checkWhiteSpace(ch, start, length)) { |
| readUnknownError("NVDLReader.UnallowedCharactersError", |
| new Object[] {new String(ch, start, length)}); |
| } |
| } |
| WSSkipHandler(BaseHandler bh) { |
| super(bh); |
| } |
| } |
| |
| private class InitialHandler extends WSSkipHandler { |
| public void startElement(String uri, |
| String localName, |
| String qName, |
| Attributes attrs) throws SAXException { |
| if (isForeign(uri) |
| || !localName.equals("rules")) { |
| readUnknownError("NVDLReader.DocumentElementIsRulesError", |
| new Object[] {uri, qName}); |
| return; |
| } |
| AtRet[] ars = new AtRet[2]; |
| ars[0] = new AtRet("schemaType"); |
| ars[1] = new AtRet("startMode"); |
| getAttrs(attrs, ars); |
| rules = new NVDLRules(ars[0].value, ars[1].value); |
| setLocation(rules); |
| setHandler(new RulesHandler(this)); |
| } |
| InitialHandler() { |
| super(null); |
| } |
| } |
| |
| private abstract class RuleHandler extends WSSkipHandler { |
| private boolean targetElement = false; |
| private boolean targetAttribute = false; |
| private void parseMatchTarget(String mt) throws SAXException { |
| if (mt.equals("elements")) { |
| targetElement = true; |
| } else if (mt.equals("attributes")) { |
| targetAttribute = true; |
| } else { |
| readInvalidError("NVDLReader.InvalidMatchTargetError", new Object[] {mt}); |
| } |
| } |
| private NVDLRule createRuleModel(boolean any, |
| String ns, |
| char wildCard, |
| String target) |
| throws SAXException { |
| targetElement = targetAttribute = false; |
| if (target == null) { |
| // Simplification 6.4.9 |
| targetElement = true; |
| } else { |
| String[] targets = splitList(target); |
| if (targets.length == 0) { |
| // Simplification 6.4.9 |
| targetElement = true; |
| } else if (targets.length == 1) { |
| parseMatchTarget(targets[0]); |
| } else if (targets.length == 2) { |
| parseMatchTarget(targets[0]); |
| parseMatchTarget(targets[1]); |
| } else { |
| readInvalidError("NVDLReader.InvalidMatchTargetError", new Object[] {target}); |
| } |
| } |
| NVDLRule rule = new NVDLRule(any, ns, wildCard, |
| targetElement, targetAttribute); |
| setLocation(rule); |
| return rule; |
| } |
| |
| protected NVDLRule parseRule(String localName, |
| Attributes attrs) throws SAXException { |
| if (localName.equals("namespace")) { |
| AtRet[] ars = new AtRet[3]; |
| ars[0] = new AtRet("ns"); |
| ars[1] = new AtRet("wildCard"); |
| ars[2] = new AtRet("match"); |
| getAttrs(attrs, ars); |
| // Simplification 6.4.9 |
| char wildCardChar = '*'; |
| if (ars[1].value == null) { |
| } else if (ars[1].value.length() == 0) { |
| wildCardChar = '\u0000'; |
| } else if (ars[1].value.length() == 1) { |
| wildCardChar = ars[1].value.charAt(0); |
| } else { |
| readInvalidError("NVDLReader.WildCardOneCharError", |
| new Object[] {ars[1].value}); |
| } |
| NVDLRule rule = createRuleModel(false, ars[0].value, |
| wildCardChar, ars[2].value); |
| parseRuleActions(this, rule); |
| return rule; |
| } else if (localName.equals("anyNamespace")) { |
| AtRet[] ars = new AtRet[1]; |
| ars[0] = new AtRet("match"); |
| getAttrs(attrs, ars); |
| NVDLRule rule = createRuleModel(true, null, ' ', ars[0].value); |
| parseRuleActions(this, rule); |
| return rule; |
| } |
| return null; |
| } |
| |
| RuleHandler(BaseHandler bh) { |
| super(bh); |
| } |
| } |
| |
| private void parseRuleActions(BaseHandler bh, NVDLRule rule) { |
| setHandler(new ActionsHandler(bh, rule)); |
| } |
| private class ActionsHandler extends WSSkipHandler { |
| private final NVDLRule baseRule; |
| private boolean cancelNestedActions = false; |
| private boolean noResultAction = false; |
| private boolean resultAction = false; |
| private void checkResultAction(String localName) throws SAXException { |
| if (resultAction) { |
| readInvalidError("NVDLReader.OneResultActionError", |
| new Object[] {localName}); |
| } |
| } |
| |
| private void parseValidate(Attributes attrs) throws SAXException { |
| AtRet[] ars = new AtRet[5]; |
| ars[0] = new AtRet("useMode"); |
| ars[1] = new AtRet("message"); |
| ars[2] = new AtRet("schemaType"); |
| ars[3] = new AtRet("schema"); |
| ars[4] = new AtRet("id"); |
| getAttrs(attrs, ars); |
| String id = uniqueActionID(attrs); |
| NVDLValidateAction action = new NVDLValidateAction(id, ars[0].value, baseRule); |
| rules.putAction(action); |
| setLocation(action); |
| baseRule.getActionManager().addNoResultAction(action); |
| if (ars[2].value != null) action.setSchemaType(ars[2].value); |
| if (ars[3].value != null) action.setSchemaIRI(ars[3].value); |
| |
| if (ars[1].value != null) { |
| action.getMessage().addMessage(null, ars[2].value); |
| } |
| |
| action.setSchemaLoader(newSchemaLoader(action.getSchemaType())); |
| |
| setHandler(new ValidateHandler(this, action)); |
| } |
| |
| private AtRet[] parseBaseActionAttributes(Attributes attrs) |
| throws SAXException { |
| AtRet[] ars = new AtRet[3]; |
| ars[0] = new AtRet("useMode"); |
| ars[1] = new AtRet("message"); |
| ars[2] = new AtRet("id"); |
| getAttrs(attrs, ars); |
| return ars; |
| } |
| |
| private void parseActionBase(NVDLAction action, |
| String message) { |
| rules.putAction(action); |
| setLocation(action); |
| if (message != null) { |
| action.getMessage().addMessage(null, message); |
| } |
| setHandler(new ActionBaseHandler(this, action)); |
| } |
| |
| public void startElement(String uri, |
| String localName, |
| String qName, |
| Attributes attrs) throws SAXException { |
| if (isForeign(uri)) { |
| setHandler(new ForeignSkipHandler(this)); |
| return; |
| } |
| if (cancelNestedActions) { |
| readInvalidError("NVDLReader.CancelNestedActionsError", |
| new Object[] {localName}); |
| } |
| if (localName.equals("cancelNestedActions")) { |
| cancelNestedActions = true; |
| checkAttrs(attrs); |
| baseRule.getActionManager().setCancelAction(); |
| setHandler(new WSSkipHandler(this)); |
| } else if (localName.equals("validate")) { |
| noResultAction = true; |
| parseValidate(attrs); |
| } else if (localName.equals("allow")) { |
| noResultAction = true; |
| AtRet[] atr = parseBaseActionAttributes(attrs); |
| String id = uniqueActionID(attrs); |
| NVDLAllowAction a = new NVDLAllowAction(id, atr[0].value, baseRule); |
| baseRule.getActionManager().addNoResultAction(a); |
| parseActionBase(a, atr[1].value); |
| } else if (localName.equals("reject")) { |
| noResultAction = true; |
| AtRet[] atr = parseBaseActionAttributes(attrs); |
| String id = uniqueActionID(attrs); |
| NVDLRejectAction a = new NVDLRejectAction(id, atr[0].value, baseRule); |
| baseRule.getActionManager().addNoResultAction(a); |
| parseActionBase(a, atr[1].value); |
| } else if (localName.equals("attach")) { |
| checkResultAction(localName); |
| resultAction = true; |
| AtRet[] atr = parseBaseActionAttributes(attrs); |
| String id = uniqueActionID(attrs); |
| NVDLResultAction a = new NVDLResultAction(id, atr[0].value, |
| NVDLResultAction.TYPE_ATTACH, |
| baseRule); |
| baseRule.getActionManager().setResultAction(a); |
| parseActionBase(a, atr[1].value); |
| } else if (localName.equals("attachPlaceHolder")) { |
| checkResultAction(localName); |
| resultAction = true; |
| AtRet[] atr = parseBaseActionAttributes(attrs); |
| String id = uniqueActionID(attrs); |
| NVDLResultAction a = new NVDLResultAction(id, atr[0].value, |
| NVDLResultAction.TYPE_ATTACHPLACEHOLDER, |
| baseRule); |
| baseRule.getActionManager().setResultAction(a); |
| parseActionBase(a, atr[1].value); |
| } else if (localName.equals("unwrap")) { |
| checkResultAction(localName); |
| resultAction = true; |
| AtRet[] atr = parseBaseActionAttributes(attrs); |
| String id = uniqueActionID(attrs); |
| NVDLResultAction a = new NVDLResultAction(id, atr[0].value, |
| NVDLResultAction.TYPE_UNWRAP, |
| baseRule); |
| baseRule.getActionManager().setResultAction(a); |
| parseActionBase(a, atr[1].value); |
| } else { |
| super.startElement(uri, localName, qName, attrs); |
| } |
| } |
| public void endElement(String namespaceURI, |
| String localName, String qName) throws SAXException { |
| super.endElement(namespaceURI, localName, qName); |
| if (!cancelNestedActions && !noResultAction && !resultAction) { |
| readInvalidError("NVDLReader.NoActionError"); |
| } |
| } |
| ActionsHandler(BaseHandler bh, NVDLRule baseRule) { |
| super(bh); |
| this.baseRule = baseRule; |
| } |
| } |
| |
| private SchemaLoader newSchemaLoader(String schemaType) { |
| return new SchemaLoader(locator.getSystemId(), newLocation()); |
| } |
| |
| private class ValidateHandler extends ActionBaseHandler { |
| private final NVDLValidateAction validateAction; |
| public void startElement(String uri, |
| String localName, |
| String qName, |
| Attributes attrs) throws SAXException { |
| if (isForeign(uri)) { |
| super.startElement(uri, localName, qName, attrs); |
| } else if (localName.equals("option")) { |
| if (actionBaseState > MESSAGE_OPTION_APPEARED) { |
| readInvalidError("NVDLReader.OptionBeforeSchemaError"); |
| } |
| actionBaseState = MESSAGE_OPTION_APPEARED; |
| AtRet[] ars = new AtRet[3]; |
| ars[0] = new AtRet("name"); |
| ars[1] = new AtRet("arg"); |
| ars[2] = new AtRet("mustSupport"); |
| getAttrs(attrs, ars); |
| if (ars[0].value == null) { |
| readInvalidError("NVDLReader.OptionHasNameError"); |
| } |
| // Simplification 6.4.5 |
| boolean mustSupport = parseXSDBoolean(ars[2].value, false); |
| validateAction.addOption(ars[0].value, ars[1].value, mustSupport); |
| setHandler(new WSSkipHandler(this)); |
| } else if (localName.equals("schema")) { |
| if (validateAction.getSchemaIRI() != null) { |
| readInvalidError("NVDLReader.SchemaAttributeSpecifiedError"); |
| } |
| if (actionBaseState > SCHEMA_APPEARED) { |
| readInvalidError("NVDLReader.SchemaBeforeModeOrContextError"); |
| } |
| actionBaseState = SCHEMA_APPEARED; |
| parseSchema(this, validateAction, attrs); |
| } else { |
| super.startElement(uri, localName, qName, attrs); |
| } |
| } |
| |
| public void endElement(String namespaceURI, |
| String localName, String qName) throws SAXException { |
| super.endElement(namespaceURI, localName, qName); |
| // schema element or attribute check. |
| if (!validateAction.isSchamaSpecified()) { |
| readInvalidError("NVDLReader.ValidateHasSchemaError"); |
| } |
| } |
| |
| ValidateHandler(BaseHandler bh, NVDLValidateAction action) { |
| super(bh, action); |
| this.validateAction = action; |
| } |
| } |
| |
| private class ActionBaseHandler extends WSSkipHandler { |
| private final NVDLAction action; |
| |
| protected static final int INITIAL = 0; |
| protected static final int MESSAGE_OPTION_APPEARED = 1; |
| protected static final int SCHEMA_APPEARED = 2; |
| protected static final int MODEUSAGE1_APPEARED = 3; |
| protected static final int CONTEXT_APPEARED = 4; |
| protected int actionBaseState = INITIAL; |
| |
| public void startElement(String uri, |
| String localName, |
| String qName, |
| Attributes attrs) throws SAXException { |
| if (isForeign(uri)) { |
| setHandler(new ForeignSkipHandler(this)); |
| return; |
| } |
| if (localName.equals("message")) { |
| if (actionBaseState > MESSAGE_OPTION_APPEARED) { |
| readInvalidError("NVDLReader.MessageBeforeSchemaError"); |
| } |
| actionBaseState = MESSAGE_OPTION_APPEARED; |
| parseMessage(this, action.getMessage(), attrs); |
| } else if (localName.equals("mode")) { |
| checkNestedMode(action); |
| if (actionBaseState > MODEUSAGE1_APPEARED) { |
| readInvalidError("NVDLReader.ModeBeforeContextError"); |
| } |
| actionBaseState = MODEUSAGE1_APPEARED; |
| action.setUseMode(parseNestedMode(this, attrs)); |
| } else if (localName.equals("context")) { |
| actionBaseState = CONTEXT_APPEARED; |
| parseContext(this, action, attrs); |
| } else { |
| super.startElement(uri, localName, qName, attrs); |
| } |
| } |
| |
| ActionBaseHandler(BaseHandler bh, NVDLAction action) { |
| super(bh); |
| this.action = action; |
| } |
| } |
| |
| private void parseMessage(BaseHandler bh, |
| NVDLMessage nm, Attributes attrs) { |
| String lang = attrs.getValue("xml:lang"); |
| setHandler(new MessageHandler(bh, nm, lang)); |
| } |
| private class MessageHandler extends BaseHandler { |
| private final NVDLMessage nm; |
| private final String lang; |
| private StringBuffer buf = new StringBuffer(); |
| |
| public void characters(char[] ch, int start, int length) |
| throws SAXException { |
| buf.append(ch, start, length); |
| } |
| |
| public void endElement(String namespaceURI, |
| String localName, String qName) throws SAXException { |
| super.endElement(namespaceURI, localName, qName); |
| nm.addMessage(lang, buf.toString()); |
| } |
| |
| MessageHandler(BaseHandler bh, NVDLMessage nm, String lang) { |
| super(bh); |
| this.nm = nm; |
| this.lang = lang; |
| } |
| } |
| |
| private void parseSchema(BaseHandler bh, |
| NVDLValidateAction action, |
| Attributes attrs) throws SAXException { |
| checkAttrs(attrs); |
| setHandler(new SchemaHandler(bh, action)); |
| } |
| private class SchemaHandler extends WSSkipHandler { |
| private NVDLValidateAction action; |
| private int level; |
| private SchemaFactory schemaFactory; |
| private SchemaReaderProxy proxyForSchemaAttribute; |
| private SchemaReaderProxy proxyForSchemaElement; |
| |
| public void setDocumentLocator(Locator locator) { |
| if (proxyForSchemaAttribute != null) { |
| proxyForSchemaAttribute.setDocumentLocator(locator); |
| } |
| if (proxyForSchemaElement != null) { |
| proxyForSchemaElement.setDocumentLocator(locator); |
| } |
| super.setDocumentLocator(locator); |
| } |
| |
| public void startElement(String uri, |
| String localName, |
| String qName, |
| Attributes attributes) throws SAXException { |
| if (level == 0) { |
| Log.debug("Try to create schemaFactory for " + uri); |
| try { |
| schemaFactory = SchemaFactory.newInstance(uri); |
| schemaFactory.setErrorHandler(eh); |
| } catch (IllegalArgumentException e){ |
| readInvalidError("NVDLReader.SchemaImplementationNotFoundError", |
| new Object[] {uri}); |
| return; |
| } |
| if (proxyForSchemaAttribute != null) { |
| proxyForSchemaAttribute.begin(schemaFactory, |
| new InputSource(locator.getSystemId()), |
| uri, true); |
| } |
| if (proxyForSchemaElement != null) { |
| proxyForSchemaElement.begin(schemaFactory, |
| new InputSource(locator.getSystemId()), |
| uri, false); |
| } |
| } |
| if (proxyForSchemaAttribute != null) { |
| proxyForSchemaAttribute.startElement(uri, localName, qName, attributes); |
| } |
| if (proxyForSchemaElement != null) { |
| proxyForSchemaElement.startElement(uri, localName, qName, attributes); |
| } |
| level++; |
| } |
| |
| public void characters(char[] ch, |
| int start, |
| int length) |
| throws SAXException { |
| if (proxyForSchemaAttribute != null) { |
| proxyForSchemaAttribute.characters(ch, start, length); |
| } |
| if (proxyForSchemaElement != null) { |
| proxyForSchemaElement.characters(ch, start, length); |
| } |
| } |
| |
| public void endElement(String uri, |
| String localName, |
| String qName) throws SAXException { |
| if (level == 0) { |
| if (proxyForSchemaAttribute != null) { |
| proxyForSchemaAttribute.end(); |
| if (proxyForSchemaAttribute.getSchema() == null) { |
| readInvalidError("NVDLReader.SchemaReadError"); |
| } |
| action.setSchema(proxyForSchemaAttribute.getSchema(), true); |
| } |
| if (proxyForSchemaElement != null) { |
| proxyForSchemaElement.end(); |
| if (proxyForSchemaElement.getSchema() == null) { |
| readInvalidError("NVDLReader.SchemaReadError"); |
| } |
| action.setSchema(proxyForSchemaElement.getSchema(), false); |
| } |
| super.endElement(uri, localName, qName); |
| } else { |
| if (proxyForSchemaAttribute != null) { |
| proxyForSchemaAttribute.endElement(uri, localName, qName); |
| } |
| if (proxyForSchemaElement != null) { |
| proxyForSchemaElement.endElement(uri, localName, qName); |
| } |
| level--; |
| } |
| } |
| |
| public void startPrefixMapping(String prefix, |
| String uri) |
| throws SAXException { |
| super.startPrefixMapping(prefix, uri); |
| if (proxyForSchemaAttribute != null) { |
| proxyForSchemaAttribute.startPrefixMapping(prefix, uri); |
| } |
| if (proxyForSchemaElement != null) { |
| proxyForSchemaElement.startPrefixMapping(prefix, uri); |
| } |
| } |
| public void endPrefixMapping(String prefix) throws SAXException { |
| super.endPrefixMapping(prefix); |
| if (proxyForSchemaAttribute != null) { |
| proxyForSchemaAttribute.endPrefixMapping(prefix); |
| } |
| if (proxyForSchemaElement != null) { |
| proxyForSchemaElement.endPrefixMapping(prefix); |
| } |
| } |
| |
| public void processingInstruction(String target, |
| String data) |
| throws SAXException { |
| if (proxyForSchemaAttribute != null) { |
| proxyForSchemaAttribute.processingInstruction(target, data); |
| } |
| if (proxyForSchemaElement != null) { |
| proxyForSchemaElement.processingInstruction(target, data); |
| } |
| } |
| |
| SchemaHandler(BaseHandler bh, |
| NVDLValidateAction action) { |
| super(bh); |
| this.action = action; |
| level = 0; |
| |
| if (action.getBelongingRule().isTargetAttribute()) { |
| this.proxyForSchemaAttribute = SchemaReaderProxy.newProxy(locator, prefixMapper); |
| this.proxyForSchemaAttribute.setErrorHandler(eh); |
| } |
| if (action.getBelongingRule().isTargetElement()) { |
| this.proxyForSchemaElement = SchemaReaderProxy.newProxy(locator, prefixMapper); |
| this.proxyForSchemaElement.setErrorHandler(eh); |
| } |
| } |
| } |
| |
| private void parseContext(BaseHandler bh, |
| NVDLAction action, Attributes attrs) |
| throws SAXException{ |
| AtRet[] ars = new AtRet[2]; |
| ars[0] = new AtRet("path"); |
| ars[1] = new AtRet("useMode"); |
| getAttrs(attrs, ars); |
| if (ars[0].value == null) { |
| readInvalidError("NVDLReader.ContextHasPathError"); |
| } |
| setHandler(new ContextHandler(bh, action, ars[0].value, ars[1].value)); |
| } |
| private class ContextHandler extends WSSkipHandler { |
| private final NVDLAction action; |
| private NVDLMode mode; |
| private final String useModeName; |
| private final String path; |
| public void startElement(String uri, |
| String localName, |
| String qName, |
| Attributes attrs) throws SAXException { |
| if (isForeign(uri)) { |
| setHandler(new ForeignSkipHandler(this)); |
| return; |
| } |
| if (localName.equals("mode")) { |
| if (useModeName != null) { |
| readInvalidError("NVDLReader.ContextHasModeButUseModeIsSpecifiedError"); |
| } |
| mode = parseNestedMode(this, attrs); |
| } else { |
| super.startElement(uri, localName, qName, attrs); |
| } |
| } |
| |
| public void endElement(String namespaceURI, |
| String localName, String qName) throws SAXException { |
| super.endElement(namespaceURI, localName, qName); |
| try { |
| if (mode == null) { |
| if (useModeName == null) { |
| readInvalidError("NVDLReader.ContextHasUseModeOrModeError"); |
| } |
| action.addContext(path, useModeName); |
| } else { |
| action.addContext(path, mode); |
| } |
| } catch (NVDLException e) { |
| readInvalidError(e.getMessage()); |
| } |
| } |
| |
| ContextHandler(BaseHandler bh, NVDLAction action, |
| String path, String useModeName) { |
| super(bh); |
| this.action = action; |
| this.path = path; |
| this.useModeName = useModeName; |
| } |
| } |
| |
| |
| private class RulesHandler extends RuleHandler { |
| private static final int INITIAL = 0; |
| private static final int TRIGGER_APPEARED = 1; |
| private static final int RULE_APPEARED = 2; |
| private static final int MODE_APPEARED = 3; |
| private int rulesState = INITIAL; |
| |
| private void parseTrigger(Attributes attrs) throws SAXException { |
| AtRet[] ars = new AtRet[2]; |
| ars[0] = new AtRet("ns"); |
| ars[1] = new AtRet("nameList"); |
| getAttrs(attrs, ars); |
| if (ars[0].value == null) { |
| readInvalidError("NVDLReader.TriggerHasNSError"); |
| } |
| if (ars[1].value == null) { |
| readInvalidError("NVDLReader.TriggerHasNameListError"); |
| } |
| rules.getTriggerManager().addTrigger(ars[0].value, |
| splitList(ars[1].value)); |
| // empty element. |
| setHandler(new WSSkipHandler(this)); |
| } |
| |
| public void startElement(String uri, |
| String localName, |
| String qName, |
| Attributes attrs) throws SAXException { |
| if (isForeign(uri)) { |
| setHandler(new ForeignSkipHandler(this)); |
| return; |
| } |
| if (localName.equals("trigger")) { |
| if (rulesState > TRIGGER_APPEARED) { |
| readInvalidError("NVDLReader.TriggerIsFirstError"); |
| } |
| rulesState = TRIGGER_APPEARED; |
| parseTrigger(attrs); |
| } else if (localName.equals("mode")) { |
| if (rulesState == RULE_APPEARED) { |
| readInvalidError("NVDLReader.ModeIsAfterRuleError"); |
| } |
| rulesState = MODE_APPEARED; |
| parseMode(this, attrs); |
| } else { |
| // Simplification 6.4.7 |
| NVDLRule rule = parseRule(localName, attrs); |
| if (rule == null) { |
| super.startElement(uri, localName, qName, attrs); |
| return; |
| } |
| if (rulesState == MODE_APPEARED) { |
| readInvalidError("NVDLReader.RuleIsAfterModeError", |
| new Object[] {localName}); |
| } |
| rulesState = RULE_APPEARED; |
| if (rules.getStartModeName() != null) { |
| readInvalidError("NVDLReader.StartModeError"); |
| } |
| NVDLMode mode = rules.getStartMode(); |
| if (mode == null) { |
| mode = new NVDLMode("nested start mode "); |
| mode.setLocation(rule.getLocation()); |
| rules.setStartMode(mode); |
| } |
| addRule(mode, rule); |
| } |
| } |
| |
| RulesHandler(BaseHandler bh) { |
| super(bh); |
| } |
| } |
| |
| // must have name; |
| private NVDLMode parseMode(BaseHandler ph, Attributes attrs) |
| throws SAXException { |
| AtRet[] ars = new AtRet[1]; |
| ars[0] = new AtRet("name"); |
| getAttrs(attrs, ars); |
| if (ars[0].value == null) { |
| readInvalidError("NVDLReader.ModeInRulesHasName"); |
| } |
| NVDLMode mode = new NVDLMode(ars[0].value); |
| setLocation(mode); |
| if (rules.getMode(mode.name) != null) { |
| readInvalidError("NVDLReader.ModeNameConflictError", |
| new Object[] {mode.name}); |
| } |
| setHandler(new ModeHandler(ph, mode)); |
| rules.putMode(mode); |
| |
| return mode; |
| } |
| // optionally has name |
| private NVDLMode parseIncludedMode(BaseHandler ph, Attributes attrs, |
| NVDLMode parentMode) |
| throws SAXException { |
| AtRet[] ars = new AtRet[1]; |
| ars[0] = new AtRet("name"); |
| getAttrs(attrs, ars); |
| NVDLMode mode = new NVDLMode(ars[0].value); |
| setLocation(mode); |
| setHandler(new ModeHandler(ph, mode)); |
| parentMode.addIncludedMode(mode); |
| return mode; |
| } |
| // has no name. |
| private NVDLMode parseNestedMode(BaseHandler ph, Attributes attrs) |
| throws SAXException { |
| checkAttrs(attrs); |
| NVDLMode mode = new NVDLMode(uniqueModeName()); |
| setLocation(mode); |
| setHandler(new ModeHandler(ph, mode)); |
| return mode; |
| } |
| private class ModeHandler extends RuleHandler { |
| private final NVDLMode mode; |
| private static final int INITIAL = 0; |
| private static final int INCLUDEDMODE_APPEARED = 1; |
| private static final int RULE_APPEARED = 2; |
| private int modeState = INITIAL; |
| |
| public void startElement(String uri, |
| String localName, |
| String qName, |
| Attributes attrs) throws SAXException { |
| if (isForeign(uri)) { |
| setHandler(new ForeignSkipHandler(this)); |
| return; |
| } |
| if (localName.equals("mode")) { |
| if (modeState > INCLUDEDMODE_APPEARED) { |
| readInvalidError("NVDLReader.IncludedModeAfterRuleError"); |
| } |
| parseIncludedMode(this, attrs, mode); |
| modeState = INCLUDEDMODE_APPEARED; |
| } else { |
| NVDLRule rule = parseRule(localName, attrs); |
| if (rule == null) { |
| super.startElement(uri, localName, qName, attrs); |
| } else { |
| addRule(mode, rule); |
| modeState = RULE_APPEARED; |
| } |
| } |
| } |
| |
| ModeHandler(BaseHandler bh, NVDLMode mode) { |
| super(bh); |
| this.mode = mode; |
| } |
| } |
| |
| public NVDLRules parse(InputSource is) throws NVDLReaderException, IOException { |
| this.errorCounter = 0; |
| try { |
| reader.parse(is); |
| if (errorCounter > 0) { |
| readInvalidError("NVDLReader.NVDLHasError", |
| new Object[] {new Integer(errorCounter)}); |
| return null; |
| } |
| NVDLSimplifier simplifier = new NVDLSimplifier(rules, eh); |
| try { |
| simplifier.traverse(rules); |
| } catch (NVDLModelException e) { |
| throw new NVDLReaderException(e); |
| } |
| if (simplifier.getErrorCount() > 0) { |
| readInvalidError("NVDLReader.NVDLHasError", |
| new Object[] {new Integer(simplifier.getErrorCount())}); |
| return null; |
| } |
| } catch (SAXException e) { |
| Exception ei = e.getException(); |
| if (ei instanceof NVDLReaderException) { |
| throw (NVDLReaderException) ei; |
| } |
| throw new NVDLReaderException(e); |
| } |
| return rules; |
| } |
| |
| public static SAXParser newSAXParser() throws SAXException { |
| SAXParserFactory pf = SAXParserFactory.newInstance(); |
| try { |
| pf.setFeature("http://xml.org/sax/features/namespaces", true); |
| pf.setFeature("http://xml.org/sax/features/namespace-prefixes", true); |
| pf.setXIncludeAware(true); |
| return pf.newSAXParser(); |
| } catch (ParserConfigurationException e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } |
| |
| public NVDLSAXReader(SAXParser parser) throws SAXException { |
| this(parser, null); |
| } |
| |
| public NVDLSAXReader(ErrorHandler eh) throws SAXException { |
| this(newSAXParser(), eh); |
| } |
| |
| public NVDLSAXReader(SAXParser parser, ErrorHandler eh) throws SAXException { |
| this.reader = parser.getXMLReader(); |
| if (eh != null) { |
| this.eh = eh; |
| } else { |
| this.eh = DefaultErrorHandler.getErrorHandler(); |
| } |
| setHandler(new InitialHandler()); |
| } |
| |
| } |
