author | joehw |
Wed, 18 Oct 2017 13:25:49 -0700 | |
changeset 47359 | e1a6c0168741 |
parent 47216 | 71c04702a3d5 |
child 48409 | 5ab69533994b |
permissions | -rw-r--r-- |
6 | 1 |
/* |
45853
bfa06be36a17
8181154: Fix lint warnings in JAXP repo: deprecation
joehw
parents:
44797
diff
changeset
|
2 |
* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. |
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
3 |
* @LastModified: Oct 2017 |
6 | 4 |
*/ |
5 |
/* |
|
44797
8b3b3b911b8a
8162572: Update License Header for all JAXP sources
joehw
parents:
31497
diff
changeset
|
6 |
* Licensed to the Apache Software Foundation (ASF) under one or more |
8b3b3b911b8a
8162572: Update License Header for all JAXP sources
joehw
parents:
31497
diff
changeset
|
7 |
* contributor license agreements. See the NOTICE file distributed with |
8b3b3b911b8a
8162572: Update License Header for all JAXP sources
joehw
parents:
31497
diff
changeset
|
8 |
* this work for additional information regarding copyright ownership. |
8b3b3b911b8a
8162572: Update License Header for all JAXP sources
joehw
parents:
31497
diff
changeset
|
9 |
* The ASF licenses this file to You under the Apache License, Version 2.0 |
8b3b3b911b8a
8162572: Update License Header for all JAXP sources
joehw
parents:
31497
diff
changeset
|
10 |
* (the "License"); you may not use this file except in compliance with |
8b3b3b911b8a
8162572: Update License Header for all JAXP sources
joehw
parents:
31497
diff
changeset
|
11 |
* the License. You may obtain a copy of the License at |
6 | 12 |
* |
44797
8b3b3b911b8a
8162572: Update License Header for all JAXP sources
joehw
parents:
31497
diff
changeset
|
13 |
* http://www.apache.org/licenses/LICENSE-2.0 |
6 | 14 |
* |
15 |
* Unless required by applicable law or agreed to in writing, software |
|
16 |
* distributed under the License is distributed on an "AS IS" BASIS, |
|
17 |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
18 |
* See the License for the specific language governing permissions and |
|
19 |
* limitations under the License. |
|
20 |
*/ |
|
21 |
||
22 |
package com.sun.org.apache.xml.internal.dtm.ref; |
|
23 |
||
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
24 |
import com.sun.org.apache.xalan.internal.utils.ObjectFactory; |
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
25 |
import com.sun.org.apache.xerces.internal.parsers.SAXParser; |
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
26 |
import com.sun.org.apache.xml.internal.res.XMLErrorResources; |
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
27 |
import com.sun.org.apache.xml.internal.res.XMLMessages; |
6 | 28 |
import java.io.IOException; |
29 |
import java.lang.reflect.Constructor; |
|
30 |
import java.lang.reflect.Method; |
|
31 |
import org.xml.sax.InputSource; |
|
32 |
import org.xml.sax.SAXException; |
|
33 |
import org.xml.sax.XMLReader; |
|
34 |
||
35 |
||
36 |
/** <p>IncrementalSAXSource_Xerces takes advantage of the fact that Xerces1 |
|
37 |
* incremental mode is already a coroutine of sorts, and just wraps our |
|
38 |
* IncrementalSAXSource API around it.</p> |
|
39 |
* |
|
40 |
* <p>Usage example: See main().</p> |
|
41 |
* |
|
42 |
* <p>Status: Passes simple main() unit-test. NEEDS JAVADOC.</p> |
|
43 |
* */ |
|
44 |
public class IncrementalSAXSource_Xerces |
|
45 |
implements IncrementalSAXSource |
|
46 |
{ |
|
47 |
// |
|
48 |
// Reflection. To allow this to compile with both Xerces1 and Xerces2, which |
|
49 |
// require very different methods and objects, we need to avoid static |
|
50 |
// references to those APIs. So until Xerces2 is pervasive and we're willing |
|
51 |
// to make it a prerequisite, we will rely upon relection. |
|
52 |
// |
|
53 |
Method fParseSomeSetup=null; // Xerces1 method |
|
54 |
Method fParseSome=null; // Xerces1 method |
|
55 |
Object fPullParserConfig=null; // Xerces2 pull control object |
|
56 |
Method fConfigSetInput=null; // Xerces2 method |
|
57 |
Method fConfigParse=null; // Xerces2 method |
|
58 |
Method fSetInputSource=null; // Xerces2 pull control method |
|
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
59 |
Constructor<?> fConfigInputSourceCtor=null; // Xerces2 initialization method |
6 | 60 |
Method fConfigSetByteStream=null; // Xerces2 initialization method |
61 |
Method fConfigSetCharStream=null; // Xerces2 initialization method |
|
62 |
Method fConfigSetEncoding=null; // Xerces2 initialization method |
|
63 |
Method fReset=null; // Both Xerces1 and Xerces2, but diff. signatures |
|
64 |
||
65 |
// |
|
66 |
// Data |
|
67 |
// |
|
68 |
SAXParser fIncrementalParser; |
|
69 |
private boolean fParseInProgress=false; |
|
70 |
||
71 |
// |
|
72 |
// Constructors |
|
73 |
// |
|
74 |
||
75 |
/** Create a IncrementalSAXSource_Xerces, and create a SAXParser |
|
76 |
* to go with it. Xerces2 incremental parsing is only supported if |
|
77 |
* this constructor is used, due to limitations in the Xerces2 API (as of |
|
78 |
* Beta 3). If you don't like that restriction, tell the Xerces folks that |
|
79 |
* there should be a simpler way to request incremental SAX parsing. |
|
80 |
* */ |
|
81 |
public IncrementalSAXSource_Xerces() |
|
82 |
throws NoSuchMethodException |
|
83 |
{ |
|
84 |
try |
|
85 |
{ |
|
31497 | 86 |
// This should be cleaned up and the use of reflection |
87 |
// removed - see JDK-8129880 |
|
88 |
||
6 | 89 |
// Xerces-2 incremental parsing support (as of Beta 3) |
90 |
// ContentHandlers still get set on fIncrementalParser (to get |
|
91 |
// conversion from XNI events to SAX events), but |
|
92 |
// _control_ for incremental parsing must be exercised via the config. |
|
93 |
// |
|
94 |
// At this time there's no way to read the existing config, only |
|
95 |
// to assert a new one... and only when creating a brand-new parser. |
|
96 |
// |
|
97 |
// Reflection is used to allow us to continue to compile against |
|
98 |
// Xerces1. If/when we can abandon the older versions of the parser, |
|
99 |
// this will simplify significantly. |
|
100 |
||
101 |
// If we can't get the magic constructor, no need to look further. |
|
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
102 |
Class<?> xniConfigClass=ObjectFactory.findProviderClass( |
6 | 103 |
"com.sun.org.apache.xerces.internal.xni.parser.XMLParserConfiguration", |
12458 | 104 |
true); |
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
105 |
Class<?>[] args1={xniConfigClass}; |
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
106 |
Constructor<?> ctor=SAXParser.class.getConstructor(args1); |
6 | 107 |
|
108 |
// Build the parser configuration object. StandardParserConfiguration |
|
109 |
// happens to implement XMLPullParserConfiguration, which is the API |
|
110 |
// we're going to want to use. |
|
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
111 |
Class<?> xniStdConfigClass=ObjectFactory.findProviderClass( |
6 | 112 |
"com.sun.org.apache.xerces.internal.parsers.StandardParserConfiguration", |
12458 | 113 |
true); |
45853
bfa06be36a17
8181154: Fix lint warnings in JAXP repo: deprecation
joehw
parents:
44797
diff
changeset
|
114 |
fPullParserConfig=xniStdConfigClass.getConstructor().newInstance(); |
6 | 115 |
Object[] args2={fPullParserConfig}; |
116 |
fIncrementalParser = (SAXParser)ctor.newInstance(args2); |
|
117 |
||
118 |
// Preload all the needed the configuration methods... I want to know they're |
|
119 |
// all here before we commit to trying to use them, just in case the |
|
120 |
// API changes again. |
|
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
121 |
Class<?> fXniInputSourceClass=ObjectFactory.findProviderClass( |
6 | 122 |
"com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource", |
12458 | 123 |
true); |
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
124 |
Class<?>[] args3={fXniInputSourceClass}; |
6 | 125 |
fConfigSetInput=xniStdConfigClass.getMethod("setInputSource",args3); |
126 |
||
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
127 |
Class<?>[] args4={String.class,String.class,String.class}; |
6 | 128 |
fConfigInputSourceCtor=fXniInputSourceClass.getConstructor(args4); |
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
129 |
Class<?>[] args5={java.io.InputStream.class}; |
6 | 130 |
fConfigSetByteStream=fXniInputSourceClass.getMethod("setByteStream",args5); |
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
131 |
Class<?>[] args6={java.io.Reader.class}; |
6 | 132 |
fConfigSetCharStream=fXniInputSourceClass.getMethod("setCharacterStream",args6); |
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
133 |
Class<?>[] args7={String.class}; |
6 | 134 |
fConfigSetEncoding=fXniInputSourceClass.getMethod("setEncoding",args7); |
135 |
||
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
136 |
Class<?>[] argsb={Boolean.TYPE}; |
6 | 137 |
fConfigParse=xniStdConfigClass.getMethod("parse",argsb); |
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
138 |
Class<?>[] noargs=new Class<?>[0]; |
6 | 139 |
fReset=fIncrementalParser.getClass().getMethod("reset",noargs); |
140 |
} |
|
141 |
catch(Exception e) |
|
142 |
{ |
|
143 |
// Fallback if this fails (implemented in createIncrementalSAXSource) is |
|
144 |
// to attempt Xerces-1 incremental setup. Can't do tail-call in |
|
145 |
// constructor, so create new, copy Xerces-1 initialization, |
|
146 |
// then throw it away... Ugh. |
|
147 |
IncrementalSAXSource_Xerces dummy=new IncrementalSAXSource_Xerces(new SAXParser()); |
|
148 |
this.fParseSomeSetup=dummy.fParseSomeSetup; |
|
149 |
this.fParseSome=dummy.fParseSome; |
|
150 |
this.fIncrementalParser=dummy.fIncrementalParser; |
|
151 |
} |
|
152 |
} |
|
153 |
||
154 |
/** Create a IncrementalSAXSource_Xerces wrapped around |
|
155 |
* an existing SAXParser. Currently this works only for recent |
|
156 |
* releases of Xerces-1. Xerces-2 incremental is currently possible |
|
157 |
* only if we are allowed to create the parser instance, due to |
|
158 |
* limitations in the API exposed by Xerces-2 Beta 3; see the |
|
159 |
* no-args constructor for that code. |
|
160 |
* |
|
161 |
* @exception if the SAXParser class doesn't support the Xerces |
|
162 |
* incremental parse operations. In that case, caller should |
|
163 |
* fall back upon the IncrementalSAXSource_Filter approach. |
|
164 |
* */ |
|
165 |
public IncrementalSAXSource_Xerces(SAXParser parser) |
|
166 |
throws NoSuchMethodException |
|
167 |
{ |
|
168 |
// Reflection is used to allow us to compile against |
|
169 |
// Xerces2. If/when we can abandon the older versions of the parser, |
|
170 |
// this constructor will simply have to fail until/unless the |
|
171 |
// Xerces2 incremental support is made available on previously |
|
172 |
// constructed SAXParser instances. |
|
173 |
fIncrementalParser=parser; |
|
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
174 |
Class<?> me=parser.getClass(); |
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
175 |
Class<?>[] parms={InputSource.class}; |
6 | 176 |
fParseSomeSetup=me.getMethod("parseSomeSetup",parms); |
47359
e1a6c0168741
8181150: Fix lint warnings in JAXP repo: rawtypes and unchecked
joehw
parents:
47216
diff
changeset
|
177 |
parms=new Class<?>[0]; |
6 | 178 |
fParseSome=me.getMethod("parseSome",parms); |
179 |
// Fallback if this fails (implemented in createIncrementalSAXSource) is |
|
180 |
// to use IncrementalSAXSource_Filter rather than Xerces-specific code. |
|
181 |
} |
|
182 |
||
183 |
// |
|
184 |
// Factories |
|
185 |
// |
|
186 |
static public IncrementalSAXSource createIncrementalSAXSource() |
|
187 |
{ |
|
188 |
try |
|
189 |
{ |
|
190 |
return new IncrementalSAXSource_Xerces(); |
|
191 |
} |
|
192 |
catch(NoSuchMethodException e) |
|
193 |
{ |
|
194 |
// Xerces version mismatch; neither Xerces1 nor Xerces2 succeeded. |
|
195 |
// Fall back on filtering solution. |
|
196 |
IncrementalSAXSource_Filter iss=new IncrementalSAXSource_Filter(); |
|
197 |
iss.setXMLReader(new SAXParser()); |
|
198 |
return iss; |
|
199 |
} |
|
200 |
} |
|
201 |
||
202 |
static public IncrementalSAXSource |
|
203 |
createIncrementalSAXSource(SAXParser parser) { |
|
204 |
try |
|
205 |
{ |
|
206 |
return new IncrementalSAXSource_Xerces(parser); |
|
207 |
} |
|
208 |
catch(NoSuchMethodException e) |
|
209 |
{ |
|
210 |
// Xerces version mismatch; neither Xerces1 nor Xerces2 succeeded. |
|
211 |
// Fall back on filtering solution. |
|
212 |
IncrementalSAXSource_Filter iss=new IncrementalSAXSource_Filter(); |
|
213 |
iss.setXMLReader(parser); |
|
214 |
return iss; |
|
215 |
} |
|
216 |
} |
|
217 |
||
218 |
// |
|
219 |
// Public methods |
|
220 |
// |
|
221 |
||
222 |
// Register handler directly with the incremental parser |
|
223 |
public void setContentHandler(org.xml.sax.ContentHandler handler) |
|
224 |
{ |
|
225 |
// Typecast required in Xerces2; SAXParser doesn't inheret XMLReader |
|
226 |
// %OPT% Cast at asignment? |
|
227 |
((XMLReader)fIncrementalParser).setContentHandler(handler); |
|
228 |
} |
|
229 |
||
230 |
// Register handler directly with the incremental parser |
|
231 |
public void setLexicalHandler(org.xml.sax.ext.LexicalHandler handler) |
|
232 |
{ |
|
233 |
// Not supported by all SAX2 parsers but should work in Xerces: |
|
234 |
try |
|
235 |
{ |
|
236 |
// Typecast required in Xerces2; SAXParser doesn't inheret XMLReader |
|
237 |
// %OPT% Cast at asignment? |
|
238 |
((XMLReader)fIncrementalParser).setProperty("http://xml.org/sax/properties/lexical-handler", |
|
239 |
handler); |
|
240 |
} |
|
241 |
catch(org.xml.sax.SAXNotRecognizedException e) |
|
242 |
{ |
|
243 |
// Nothing we can do about it |
|
244 |
} |
|
245 |
catch(org.xml.sax.SAXNotSupportedException e) |
|
246 |
{ |
|
247 |
// Nothing we can do about it |
|
248 |
} |
|
249 |
} |
|
250 |
||
251 |
// Register handler directly with the incremental parser |
|
252 |
public void setDTDHandler(org.xml.sax.DTDHandler handler) |
|
253 |
{ |
|
254 |
// Typecast required in Xerces2; SAXParser doesn't inheret XMLReader |
|
255 |
// %OPT% Cast at asignment? |
|
256 |
((XMLReader)fIncrementalParser).setDTDHandler(handler); |
|
257 |
} |
|
258 |
||
259 |
//================================================================ |
|
260 |
/** startParse() is a simple API which tells the IncrementalSAXSource |
|
261 |
* to begin reading a document. |
|
262 |
* |
|
263 |
* @throws SAXException is parse thread is already in progress |
|
264 |
* or parsing can not be started. |
|
265 |
* */ |
|
266 |
public void startParse(InputSource source) throws SAXException |
|
267 |
{ |
|
268 |
if (fIncrementalParser==null) |
|
269 |
throw new SAXException(XMLMessages.createXMLMessage(XMLErrorResources.ER_STARTPARSE_NEEDS_SAXPARSER, null)); //"startParse needs a non-null SAXParser."); |
|
270 |
if (fParseInProgress) |
|
271 |
throw new SAXException(XMLMessages.createXMLMessage(XMLErrorResources.ER_STARTPARSE_WHILE_PARSING, null)); //"startParse may not be called while parsing."); |
|
272 |
||
273 |
boolean ok=false; |
|
274 |
||
275 |
try |
|
276 |
{ |
|
277 |
ok = parseSomeSetup(source); |
|
278 |
} |
|
279 |
catch(Exception ex) |
|
280 |
{ |
|
281 |
throw new SAXException(ex); |
|
282 |
} |
|
283 |
||
284 |
if(!ok) |
|
285 |
throw new SAXException(XMLMessages.createXMLMessage(XMLErrorResources.ER_COULD_NOT_INIT_PARSER, null)); //"could not initialize parser with"); |
|
286 |
} |
|
287 |
||
288 |
||
289 |
/** deliverMoreNodes() is a simple API which tells the coroutine |
|
290 |
* parser that we need more nodes. This is intended to be called |
|
291 |
* from one of our partner routines, and serves to encapsulate the |
|
292 |
* details of how incremental parsing has been achieved. |
|
293 |
* |
|
294 |
* @param parsemore If true, tells the incremental parser to generate |
|
295 |
* another chunk of output. If false, tells the parser that we're |
|
296 |
* satisfied and it can terminate parsing of this document. |
|
297 |
* @return Boolean.TRUE if the CoroutineParser believes more data may be available |
|
298 |
* for further parsing. Boolean.FALSE if parsing ran to completion. |
|
299 |
* Exception if the parser objected for some reason. |
|
300 |
* */ |
|
301 |
public Object deliverMoreNodes (boolean parsemore) |
|
302 |
{ |
|
303 |
if(!parsemore) |
|
304 |
{ |
|
305 |
fParseInProgress=false; |
|
306 |
return Boolean.FALSE; |
|
307 |
} |
|
308 |
||
309 |
Object arg; |
|
310 |
try { |
|
311 |
boolean keepgoing = parseSome(); |
|
312 |
arg = keepgoing ? Boolean.TRUE : Boolean.FALSE; |
|
313 |
} catch (SAXException ex) { |
|
314 |
arg = ex; |
|
315 |
} catch (IOException ex) { |
|
316 |
arg = ex; |
|
317 |
} catch (Exception ex) { |
|
318 |
arg = new SAXException(ex); |
|
319 |
} |
|
320 |
return arg; |
|
321 |
} |
|
322 |
||
323 |
// Private methods -- conveniences to hide the reflection details |
|
324 |
private boolean parseSomeSetup(InputSource source) |
|
325 |
throws SAXException, IOException, IllegalAccessException, |
|
326 |
java.lang.reflect.InvocationTargetException, |
|
327 |
java.lang.InstantiationException |
|
328 |
{ |
|
329 |
if(fConfigSetInput!=null) |
|
330 |
{ |
|
331 |
// Obtain input from SAX inputSource object, construct XNI version of |
|
332 |
// that object. Logic adapted from Xerces2. |
|
333 |
Object[] parms1={source.getPublicId(),source.getSystemId(),null}; |
|
334 |
Object xmlsource=fConfigInputSourceCtor.newInstance(parms1); |
|
335 |
Object[] parmsa={source.getByteStream()}; |
|
336 |
fConfigSetByteStream.invoke(xmlsource,parmsa); |
|
337 |
parmsa[0]=source.getCharacterStream(); |
|
338 |
fConfigSetCharStream.invoke(xmlsource,parmsa); |
|
339 |
parmsa[0]=source.getEncoding(); |
|
340 |
fConfigSetEncoding.invoke(xmlsource,parmsa); |
|
341 |
||
342 |
// Bugzilla5272 patch suggested by Sandy Gao. |
|
343 |
// Has to be reflection to run with Xerces2 |
|
344 |
// after compilation against Xerces1. or vice |
|
345 |
// versa, due to return type mismatches. |
|
346 |
Object[] noparms=new Object[0]; |
|
347 |
fReset.invoke(fIncrementalParser,noparms); |
|
348 |
||
349 |
parmsa[0]=xmlsource; |
|
350 |
fConfigSetInput.invoke(fPullParserConfig,parmsa); |
|
351 |
||
352 |
// %REVIEW% Do first pull. Should we instead just return true? |
|
353 |
return parseSome(); |
|
354 |
} |
|
355 |
else |
|
356 |
{ |
|
357 |
Object[] parm={source}; |
|
358 |
Object ret=fParseSomeSetup.invoke(fIncrementalParser,parm); |
|
359 |
return ((Boolean)ret).booleanValue(); |
|
360 |
} |
|
361 |
} |
|
362 |
// Would null work??? |
|
363 |
private static final Object[] noparms=new Object[0]; |
|
364 |
private static final Object[] parmsfalse={Boolean.FALSE}; |
|
365 |
private boolean parseSome() |
|
366 |
throws SAXException, IOException, IllegalAccessException, |
|
367 |
java.lang.reflect.InvocationTargetException |
|
368 |
{ |
|
369 |
// Take next parsing step, return false iff parsing complete: |
|
370 |
if(fConfigSetInput!=null) |
|
371 |
{ |
|
372 |
Object ret=(Boolean)(fConfigParse.invoke(fPullParserConfig,parmsfalse)); |
|
373 |
return ((Boolean)ret).booleanValue(); |
|
374 |
} |
|
375 |
else |
|
376 |
{ |
|
377 |
Object ret=fParseSome.invoke(fIncrementalParser,noparms); |
|
378 |
return ((Boolean)ret).booleanValue(); |
|
379 |
} |
|
380 |
} |
|
381 |
||
382 |
||
383 |
//================================================================ |
|
384 |
/** Simple unit test. Attempt coroutine parsing of document indicated |
|
385 |
* by first argument (as a URI), report progress. |
|
386 |
*/ |
|
45853
bfa06be36a17
8181154: Fix lint warnings in JAXP repo: deprecation
joehw
parents:
44797
diff
changeset
|
387 |
@Deprecated |
6 | 388 |
public static void _main(String args[]) |
389 |
{ |
|
390 |
System.out.println("Starting..."); |
|
391 |
||
392 |
CoroutineManager co = new CoroutineManager(); |
|
393 |
int appCoroutineID = co.co_joinCoroutineSet(-1); |
|
394 |
if (appCoroutineID == -1) |
|
395 |
{ |
|
396 |
System.out.println("ERROR: Couldn't allocate coroutine number.\n"); |
|
397 |
return; |
|
398 |
} |
|
399 |
IncrementalSAXSource parser= |
|
400 |
createIncrementalSAXSource(); |
|
401 |
||
402 |
// Use a serializer as our sample output |
|
403 |
com.sun.org.apache.xml.internal.serialize.XMLSerializer trace; |
|
404 |
trace=new com.sun.org.apache.xml.internal.serialize.XMLSerializer(System.out,null); |
|
405 |
parser.setContentHandler(trace); |
|
406 |
parser.setLexicalHandler(trace); |
|
407 |
||
408 |
// Tell coroutine to begin parsing, run while parsing is in progress |
|
409 |
||
410 |
for(int arg=0;arg<args.length;++arg) |
|
411 |
{ |
|
412 |
try |
|
413 |
{ |
|
414 |
InputSource source = new InputSource(args[arg]); |
|
415 |
Object result=null; |
|
416 |
boolean more=true; |
|
417 |
parser.startParse(source); |
|
418 |
for(result = parser.deliverMoreNodes(more); |
|
419 |
result==Boolean.TRUE; |
|
420 |
result = parser.deliverMoreNodes(more)) |
|
421 |
{ |
|
422 |
System.out.println("\nSome parsing successful, trying more.\n"); |
|
423 |
||
424 |
// Special test: Terminate parsing early. |
|
425 |
if(arg+1<args.length && "!".equals(args[arg+1])) |
|
426 |
{ |
|
427 |
++arg; |
|
428 |
more=false; |
|
429 |
} |
|
430 |
||
431 |
} |
|
432 |
||
433 |
if (result instanceof Boolean && ((Boolean)result)==Boolean.FALSE) |
|
434 |
{ |
|
435 |
System.out.println("\nParser ended (EOF or on request).\n"); |
|
436 |
} |
|
437 |
else if (result == null) { |
|
438 |
System.out.println("\nUNEXPECTED: Parser says shut down prematurely.\n"); |
|
439 |
} |
|
440 |
else if (result instanceof Exception) { |
|
441 |
throw new com.sun.org.apache.xml.internal.utils.WrappedRuntimeException((Exception)result); |
|
442 |
// System.out.println("\nParser threw exception:"); |
|
443 |
// ((Exception)result).printStackTrace(); |
|
444 |
} |
|
445 |
||
446 |
} |
|
447 |
||
448 |
catch(SAXException e) |
|
449 |
{ |
|
450 |
e.printStackTrace(); |
|
451 |
} |
|
452 |
} |
|
453 |
||
454 |
} |
|
455 |
||
456 |
||
457 |
} // class IncrementalSAXSource_Xerces |