protected List<NotationDeclaration> getNotationDecls() { if (fEventType == XMLStreamConstants.DTD) { if (fScanner.fDTDScanner == null) { return null; } DTDGrammar grammar = ((XMLDTDScannerImpl) (fScanner.fDTDScanner)).getGrammar(); if (grammar == null) { return null; } List<XMLNotationDecl> notations = grammar.getNotationDecls(); ArrayList<NotationDeclaration> list = new ArrayList<>(); for (XMLNotationDecl notation : notations) { if (notation != null) { list.add(new NotationDeclarationImpl(notation)); } } return list; } return null; }
private DTDSubsetImpl(boolean cachable, HashMap<String,EntityDecl> genEnt, Set<String> refdGEs, HashMap<String,EntityDecl> paramEnt, Set<String> peRefs, HashMap<String,NotationDeclaration> notations, HashMap<PrefixedName,DTDElement> elements, boolean fullyValidating) { mIsCachable = cachable; mGeneralEntities = genEnt; mRefdGEs = refdGEs; mDefinedPEs = paramEnt; mRefdPEs = peRefs; mNotations = notations; mElements = elements; mFullyValidating = fullyValidating; boolean anyNsDefs = false; if (elements != null) { for (DTDElement elem : elements.values()) { if (elem.hasNsDefaults()) { anyNsDefs = true; break; } } } mHasNsDefaults = anyNsDefs; }
/** * DTDEvent instances constructed via event reader are missing the notation * and entity declaration information */ @Test public void testDTDEvent() { String XML = "<?xml version='1.0' ?>" + "<!DOCTYPE root [\n" + "<!ENTITY intEnt 'internal'>\n" + "<!ENTITY extParsedEnt SYSTEM 'url:dummy'>\n" + "<!NOTATION notation PUBLIC 'notation-public-id'>\n" + "<!NOTATION notation2 SYSTEM 'url:dummy'>\n" + "<!ENTITY extUnparsedEnt SYSTEM 'url:dummy2' NDATA notation>\n" + "]>" + "<root />"; try { XMLEventReader er = getReader(XML); XMLEvent evt = er.nextEvent(); // StartDocument evt = er.nextEvent(); // DTD if (evt.getEventType() != XMLStreamConstants.DTD) { Assert.fail("Expected DTD event"); } DTD dtd = (DTD) evt; List entities = dtd.getEntities(); if (entities == null) { Assert.fail("No entity found. Expected 3."); } else { Assert.assertEquals(entities.size(), 3); } // Let's also verify they are all of right type... testListElems(entities, EntityDeclaration.class); List notations = dtd.getNotations(); if (notations == null) { Assert.fail("No notation found. Expected 2."); } else { Assert.assertEquals(notations.size(), 2); } // Let's also verify they are all of right type... testListElems(notations, NotationDeclaration.class); } catch (Exception e) { Assert.fail(e.getMessage()); } }
@Override public List<NotationDeclaration> getNotations() { if (mNotations == null && (mSubset != null)) { mNotations = new ArrayList<NotationDeclaration>(mSubset.getNotationList()); } return mNotations; }
public static DTDSubsetImpl constructInstance(boolean cachable, HashMap<String,EntityDecl> genEnt, Set<String> refdGEs, HashMap<String,EntityDecl> paramEnt, Set<String> refdPEs, HashMap<String,NotationDeclaration> notations, HashMap<PrefixedName,DTDElement> elements, boolean fullyValidating) { return new DTDSubsetImpl(cachable, genEnt, refdGEs, paramEnt, refdPEs, notations, elements, fullyValidating); }
@Override public synchronized List<NotationDeclaration> getNotationList() { List<NotationDeclaration> l = mNotationList; if (l == null) { if (mNotations == null || mNotations.size() == 0) { l = Collections.emptyList(); } else { l = Collections.unmodifiableList(new ArrayList<NotationDeclaration>(mNotations.values())); } mNotationList = l; } return l; }
public static void throwNotationException(NotationDeclaration oldDecl, NotationDeclaration newDecl) throws XMLStreamException { throw new WstxParsingException (MessageFormat.format(ErrorConsts.ERR_DTD_NOTATION_REDEFD, new Object[] { newDecl.getName(), oldDecl.getLocation().toString()}), newDecl.getLocation()); }
private static void checkNotations(HashMap<String,NotationDeclaration> fromInt, HashMap<String,NotationDeclaration> fromExt) throws XMLStreamException { /* Since it's external subset that would try to redefine things * defined in internal subset, let's traverse definitions in * the ext. subset first (even though that may not be the fastest * way), so that we have a chance of catching the first problem * (As long as Maps iterate in insertion order). */ for (Map.Entry<String, NotationDeclaration> en : fromExt.entrySet()) { if (fromInt.containsKey(en.getKey())) { throwNotationException(fromInt.get(en.getKey()), en.getValue()); } } }
public void testSimpleNotation() throws XMLStreamException { XMLStreamReader sr = getReader(UNPARSED_ENTITY_XML, true); assertTokenType(DTD, sr.next()); List<?> l = (List<?>) sr.getProperty("javax.xml.stream.notations"); assertNotNull(l); assertEquals(1, l.size()); NotationDeclaration nd = (NotationDeclaration) l.get(0); assertEquals("mynot", nd.getName()); }
public void setNotations(List<NotationDeclaration> notations) { fNotations = notations; }
@Override public List<NotationDeclaration> getNotations() { return fNotations; }
@Override protected void parseInternal() throws SAXException, XMLStreamException { boolean documentStarted = false; boolean documentEnded = false; int elementDepth = 0; while (this.reader.hasNext() && elementDepth >= 0) { XMLEvent event = this.reader.nextEvent(); if (!event.isStartDocument() && !event.isEndDocument() && !documentStarted) { handleStartDocument(event); documentStarted = true; } switch (event.getEventType()) { case XMLStreamConstants.START_DOCUMENT: handleStartDocument(event); documentStarted = true; break; case XMLStreamConstants.START_ELEMENT: elementDepth++; handleStartElement(event.asStartElement()); break; case XMLStreamConstants.END_ELEMENT: elementDepth--; if (elementDepth >= 0) { handleEndElement(event.asEndElement()); } break; case XMLStreamConstants.PROCESSING_INSTRUCTION: handleProcessingInstruction((ProcessingInstruction) event); break; case XMLStreamConstants.CHARACTERS: case XMLStreamConstants.SPACE: case XMLStreamConstants.CDATA: handleCharacters(event.asCharacters()); break; case XMLStreamConstants.END_DOCUMENT: handleEndDocument(); documentEnded = true; break; case XMLStreamConstants.NOTATION_DECLARATION: handleNotationDeclaration((NotationDeclaration) event); break; case XMLStreamConstants.ENTITY_DECLARATION: handleEntityDeclaration((EntityDeclaration) event); break; case XMLStreamConstants.COMMENT: handleComment((Comment) event); break; case XMLStreamConstants.DTD: handleDtd((DTD) event); break; case XMLStreamConstants.ENTITY_REFERENCE: handleEntityReference((EntityReference) event); break; } } if (documentStarted && !documentEnded) { handleEndDocument(); } }
private void handleNotationDeclaration(NotationDeclaration declaration) throws SAXException { if (getDTDHandler() != null) { getDTDHandler().notationDecl(declaration.getName(), declaration.getPublicId(), declaration.getSystemId()); } }
/** * Common initialization part of int/ext subset constructors. */ private FullDTDReader(WstxInputSource input, ReaderConfig cfg, boolean isExt, DTDSubset intSubset, boolean constructFully, int xmlVersion) { super(input, cfg, isExt); /* What matters here is what the main xml doc had; that determines * xml conformance level to use. */ mDocXmlVersion = xmlVersion; mXml11 = cfg.isXml11(); int cfgFlags = cfg.getConfigFlags(); mConfigFlags = cfgFlags; mCfgSupportDTDPP = (cfgFlags & CFG_SUPPORT_DTDPP) != 0; mCfgFullyValidating = constructFully; mUsesPredefdEntities = false; mParamEntities = null; mRefdPEs = null; mRefdGEs = null; mGeneralEntities = null; // Did we get any existing parameter entities? HashMap<String,EntityDecl> pes = (intSubset == null) ? null : intSubset.getParameterEntityMap(); if (pes == null || pes.isEmpty()) { mPredefdPEs = null; } else { mPredefdPEs = pes; } // How about general entities (needed only for attr. def. values) HashMap<String,EntityDecl> ges = (intSubset == null) ? null : intSubset.getGeneralEntityMap(); if (ges == null || ges.isEmpty()) { mPredefdGEs = null; } else { mPredefdGEs = ges; } // And finally, notations HashMap<String,NotationDeclaration> not = (intSubset == null) ? null : intSubset.getNotationMap(); if (not == null || not.isEmpty()) { mPredefdNotations = null; } else { mPredefdNotations = not; } mEventListener = mConfig.getDTDEventListener(); }
/** * Method that will combine definitions from internal and external subsets, * producing a single DTD set. */ @Override public DTDSubset combineWithExternalSubset(InputProblemReporter rep, DTDSubset extSubset) throws XMLStreamException { /* First let's see if we can just reuse GE Map used by int or ext * subset; (if only one has contents), or if not, combine them. */ HashMap<String,EntityDecl> ge1 = getGeneralEntityMap(); HashMap<String,EntityDecl> ge2 = extSubset.getGeneralEntityMap(); if (ge1 == null || ge1.isEmpty()) { ge1 = ge2; } else { if (ge2 != null && !ge2.isEmpty()) { /* Internal subset Objects are never shared or reused (and by * extension, neither are objects they contain), so we can just * modify GE map if necessary */ combineMaps(ge1, ge2); } } // Ok, then, let's combine notations similarly HashMap<String,NotationDeclaration> n1 = getNotationMap(); HashMap<String,NotationDeclaration> n2 = extSubset.getNotationMap(); if (n1 == null || n1.isEmpty()) { n1 = n2; } else { if (n2 != null && !n2.isEmpty()) { /* First; let's make sure there are no colliding notation * definitions: it's an error to try to redefine notations. */ checkNotations(n1, n2); /* Internal subset Objects are never shared or reused (and by * extension, neither are objects they contain), so we can just * modify notation map if necessary */ combineMaps(n1, n2); } } // And finally elements, rather similarly: HashMap<PrefixedName,DTDElement> e1 = getElementMap(); HashMap<PrefixedName,DTDElement> e2 = extSubset.getElementMap(); if (e1 == null || e1.isEmpty()) { e1 = e2; } else { if (e2 != null && !e2.isEmpty()) { /* Internal subset Objects are never shared or reused (and by * extension, neither are objects they contain), so we can just * modify element map if necessary */ combineElements(rep, e1, e2); } } /* Combos are not cachable, and because of that, there's no point * in storing any PE info either. */ return constructInstance(false, ge1, null, null, null, n1, e1, mFullyValidating); }
@Override public HashMap<String,NotationDeclaration> getNotationMap() { return mNotations; }
public abstract HashMap<String,NotationDeclaration> getNotationMap();
public abstract List<NotationDeclaration> getNotationList();
