1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 /*
6 * Licensed to the Apache Software Foundation (ASF) under one or more
7 * contributor license agreements. See the NOTICE file distributed with
8 * this work for additional information regarding copyright ownership.
9 * The ASF licenses this file to You under the Apache License, Version 2.0
10 * (the "License"); you may not use this file except in compliance with
11 * the License. You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
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.xerces.internal.xpointer;
23
24 import java.util.ArrayList;
25 import java.util.HashMap;
26
27 import com.sun.org.apache.xerces.internal.impl.Constants;
28 import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;
29 import com.sun.org.apache.xerces.internal.util.SymbolTable;
30 import com.sun.org.apache.xerces.internal.util.XMLChar;
31 import com.sun.org.apache.xerces.internal.util.XMLSymbols;
32 import com.sun.org.apache.xerces.internal.xinclude.XIncludeHandler;
33 import com.sun.org.apache.xerces.internal.xinclude.XIncludeNamespaceSupport;
34 import com.sun.org.apache.xerces.internal.xni.Augmentations;
35 import com.sun.org.apache.xerces.internal.xni.QName;
36 import com.sun.org.apache.xerces.internal.xni.XMLAttributes;
37 import com.sun.org.apache.xerces.internal.xni.XMLDocumentHandler;
38 import com.sun.org.apache.xerces.internal.xni.XMLString;
39 import com.sun.org.apache.xerces.internal.xni.XNIException;
40 import com.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;
41 import com.sun.org.apache.xerces.internal.xni.parser.XMLErrorHandler;
42
43 /**
44 * <p>
45 * This is a pipeline component which extends the XIncludeHandler to perform
46 * XPointer specific processing specified in the W3C XPointerFramework and
47 * element() Scheme Recommendations.
48 * </p>
49 *
50 * <p>
51 * This component analyzes each event in the pipeline, looking for an element
52 * that matches a PointerPart in the parent XInclude element's xpointer attribute
53 * value. If the match succeeds, all children are passed by this component.
54 * </p>
55 *
56 * <p>
57 * See the <a href="http://www.w3.org/TR/xptr-framework//">XPointer Framework Recommendation</a> for
58 * more information on the XPointer Framework and ShortHand Pointers.
59 * See the <a href="http://www.w3.org/TR/xptr-element/">XPointer element() Scheme Recommendation</a> for
60 * more information on the XPointer element() Scheme.
61 * </p>
62 *
63 * @xerces.internal
64 *
65 */
66 public final class XPointerHandler extends XIncludeHandler implements
67 XPointerProcessor {
68
69 // Fields
70 // An ArrayList of XPointerParts
71 protected ArrayList<XPointerPart> fXPointerParts = null;
72
73 // The current XPointerPart
74 protected XPointerPart fXPointerPart = null;
75
76 // Has the fXPointerPart resolved successfully
77 protected boolean fFoundMatchingPtrPart = false;
78
79 // The XPointer Error reporter
80 protected XMLErrorReporter fXPointerErrorReporter;
81
82 // The XPointer Error Handler
83 protected XMLErrorHandler fErrorHandler;
84
85 // XPointerFramework symbol table
86 protected SymbolTable fSymbolTable = null;
87
88 // Supported schemes
89 private final String ELEMENT_SCHEME_NAME = "element";
90
91 // Has the XPointer resolved the subresource
92 protected boolean fIsXPointerResolved = false;
93
94 // Fixup xml:base and xml:lang attributes
95 protected boolean fFixupBase = false;
96 protected boolean fFixupLang = false;
97
98 // ************************************************************************
99 // Constructors
100 // ************************************************************************
101
102 /**
103 *
104 */
105 public XPointerHandler() {
106 super();
107
108 fXPointerParts = new ArrayList<>();
109 fSymbolTable = new SymbolTable();
110 }
111
112 public XPointerHandler(SymbolTable symbolTable,
113 XMLErrorHandler errorHandler, XMLErrorReporter errorReporter) {
114 super();
115
116 fXPointerParts = new ArrayList<>();
117 fSymbolTable = symbolTable;
118 fErrorHandler = errorHandler;
119 fXPointerErrorReporter = errorReporter;
120 //fErrorReporter = errorReporter; // The XInclude ErrorReporter
121 }
122
123 public void setDocumentHandler(XMLDocumentHandler handler) {
124 fDocumentHandler = handler;
125 }
126
127 // ************************************************************************
128 // Implementation of the XPointerProcessor interface.
129 // ************************************************************************
130
131 /**
132 * Parses the XPointer framework expression and delegates scheme specific parsing.
133 *
134 * @see com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#parseXPointer(java.lang.String)
135 */
136 public void parseXPointer(String xpointer) throws XNIException {
137
138 // Initialize
139 init();
140
141 // tokens
142 final Tokens tokens = new Tokens(fSymbolTable);
143
144 // scanner
145 Scanner scanner = new Scanner(fSymbolTable) {
146 protected void addToken(Tokens tokens, int token)
147 throws XNIException {
148 if (token == Tokens.XPTRTOKEN_OPEN_PAREN
149 || token == Tokens.XPTRTOKEN_CLOSE_PAREN
150 || token == Tokens.XPTRTOKEN_SCHEMENAME
151 || token == Tokens.XPTRTOKEN_SCHEMEDATA
152 || token == Tokens.XPTRTOKEN_SHORTHAND) {
153 super.addToken(tokens, token);
154 return;
155 }
156 reportError("InvalidXPointerToken", new Object[] { tokens
157 .getTokenString(token) });
158 }
159 };
160
161 // scan the XPointer expression
162 int length = xpointer.length();
163 boolean success = scanner.scanExpr(fSymbolTable, tokens, xpointer, 0,
164 length);
165
166 if (!success)
167 reportError("InvalidXPointerExpression", new Object[] { xpointer });
168
169 while (tokens.hasMore()) {
170 int token = tokens.nextToken();
171
172 switch (token) {
173 case Tokens.XPTRTOKEN_SHORTHAND: {
174
175 // The shortHand name
176 token = tokens.nextToken();
177 String shortHandPointerName = tokens.getTokenString(token);
178
179 if (shortHandPointerName == null) {
180 reportError("InvalidXPointerExpression",
181 new Object[] { xpointer });
182 }
183
184 XPointerPart shortHandPointer = new ShortHandPointer(
185 fSymbolTable);
186 shortHandPointer.setSchemeName(shortHandPointerName);
187 fXPointerParts.add(shortHandPointer);
188 break;
189 }
190 case Tokens.XPTRTOKEN_SCHEMENAME: {
191
192 // Retreive the local name and prefix to form the scheme name
193 token = tokens.nextToken();
194 String prefix = tokens.getTokenString(token);
195 token = tokens.nextToken();
196 String localName = tokens.getTokenString(token);
197
198 String schemeName = prefix + localName;
199
200 // The next character should be an open parenthesis
201 int openParenCount = 0;
202 int closeParenCount = 0;
203
204 token = tokens.nextToken();
205 String openParen = tokens.getTokenString(token);
206 if (openParen != "XPTRTOKEN_OPEN_PAREN") {
207
208 // can not have more than one ShortHand Pointer
209 if (token == Tokens.XPTRTOKEN_SHORTHAND) {
210 reportError("MultipleShortHandPointers",
211 new Object[] { xpointer });
212 } else {
213 reportError("InvalidXPointerExpression",
214 new Object[] { xpointer });
215 }
216 }
217 openParenCount++;
218
219 // followed by zero or more ( and the schemeData
220 String schemeData = null;
221 while (tokens.hasMore()) {
222 token = tokens.nextToken();
223 schemeData = tokens.getTokenString(token);
224 if (schemeData != "XPTRTOKEN_OPEN_PAREN") {
225 break;
226 }
227 openParenCount++;
228 }
229 token = tokens.nextToken();
230 schemeData = tokens.getTokenString(token);
231
232 // followed by the same number of )
233 token = tokens.nextToken();
234 String closeParen = tokens.getTokenString(token);
235 if (closeParen != "XPTRTOKEN_CLOSE_PAREN") {
236 reportError("SchemeDataNotFollowedByCloseParenthesis",
237 new Object[] { xpointer });
238 }
239 closeParenCount++;
240
241 while (tokens.hasMore()) {
242 if (tokens.getTokenString(tokens.peekToken()) != "XPTRTOKEN_OPEN_PAREN") {
243 break;
244 }
245 closeParenCount++;
246 }
247
248 // check if the number of open parenthesis are equal to the number of close parenthesis
249 if (openParenCount != closeParenCount) {
250 reportError("UnbalancedParenthesisInXPointerExpression",
251 new Object[] { xpointer,
252 new Integer(openParenCount),
253 new Integer(closeParenCount) });
254 }
255
256 // Perform scheme specific parsing of the pointer part
257 if (schemeName.equals(ELEMENT_SCHEME_NAME)) {
258 XPointerPart elementSchemePointer = new ElementSchemePointer(
259 fSymbolTable, fErrorReporter);
260 elementSchemePointer.setSchemeName(schemeName);
261 elementSchemePointer.setSchemeData(schemeData);
262
263 // If an exception occurs while parsing the element() scheme expression
264 // ignore it and move on to the next pointer part
265 try {
266 elementSchemePointer.parseXPointer(schemeData);
267 fXPointerParts.add(elementSchemePointer);
268 } catch (XNIException e) {
269 // Re-throw the XPointer element() scheme syntax error.
270 throw new XNIException (e);
271 }
272
273 } else {
274 // ????
275 reportWarning("SchemeUnsupported",
276 new Object[] { schemeName });
277 }
278
279 break;
280 }
281 default:
282 reportError("InvalidXPointerExpression",
283 new Object[] { xpointer });
284 }
285 }
286
287 }
288
289 /**
290 *
291 * @see com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#resolveXPointer(com.sun.org.apache.xerces.internal.xni.QName, com.sun.org.apache.xerces.internal.xni.XMLAttributes, com.sun.org.apache.xerces.internal.xni.Augmentations, int event)
292 */
293 public boolean resolveXPointer(QName element, XMLAttributes attributes,
294 Augmentations augs, int event) throws XNIException {
295 boolean resolved = false;
296
297 // The result of the first pointer part whose evaluation identifies
298 // one or more subresources is reported by the XPointer processor as the
299 // result of the pointer as a whole, and evaluation stops.
300 // In our implementation, typically the first xpointer scheme that
301 // matches an element is the document is considered.
302 // If the pointer part resolved then use it, else search for the fragment
303 // using next pointer part from lef-right.
304 if (!fFoundMatchingPtrPart) {
305
306 // for each element, attempt to resolve it against each pointer part
307 // in the XPointer expression until a matching element is found.
308 for (int i = 0; i < fXPointerParts.size(); i++) {
309
310 fXPointerPart = fXPointerParts.get(i);
311
312 if (fXPointerPart.resolveXPointer(element, attributes, augs,
313 event)) {
314 fFoundMatchingPtrPart = true;
315 resolved = true;
316 }
317 }
318 } else {
319 if (fXPointerPart.resolveXPointer(element, attributes, augs, event)) {
320 resolved = true;
321 }
322 }
323
324 if (!fIsXPointerResolved) {
325 fIsXPointerResolved = resolved;
326 }
327
328 return resolved;
329 }
330
331 /**
332 * Returns true if the Node fragment is resolved.
333 *
334 * @see com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#isFragmentResolved()
335 */
336 public boolean isFragmentResolved() throws XNIException {
337 boolean resolved = (fXPointerPart != null) ? fXPointerPart.isFragmentResolved()
338 : false;
339
340 if (!fIsXPointerResolved) {
341 fIsXPointerResolved = resolved;
342 }
343
344 return resolved;
345 }
346
347 /**
348 * Returns true if the XPointer expression resolves to a non-element child
349 * of the current resource fragment.
350 *
351 * @see com.sun.org.apache.xerces.internal.xpointer.XPointerPart#isChildFragmentResolved()
352 *
353 */
354 public boolean isChildFragmentResolved() throws XNIException {
355 boolean resolved = (fXPointerPart != null) ? fXPointerPart
356 .isChildFragmentResolved() : false;
357 return resolved;
358 }
359
360 /**
361 * Returns true if the XPointer successfully found a sub-resource .
362 *
363 * @see com.sun.org.apache.xerces.internal.xpointer.XPointerProcessor#isFragmentResolved()
364 */
365 public boolean isXPointerResolved() throws XNIException {
366 return fIsXPointerResolved;
367 }
368
369 /**
370 * Returns the pointer part used to resolve the document fragment.
371 *
372 * @return String - The pointer part used to resolve the document fragment.
373 */
374 public XPointerPart getXPointerPart() {
375 return fXPointerPart;
376 }
377
378 /**
379 * Reports XPointer Errors
380 *
381 */
382 private void reportError(String key, Object[] arguments)
383 throws XNIException {
384 /*
385 fXPointerErrorReporter.reportError(
386 XPointerMessageFormatter.XPOINTER_DOMAIN, key, arguments,
387 XMLErrorReporter.SEVERITY_ERROR);
388 */
389 throw new XNIException((fErrorReporter
390 .getMessageFormatter(XPointerMessageFormatter.XPOINTER_DOMAIN))
391 .formatMessage(fErrorReporter.getLocale(), key, arguments));
392 }
393
394 /**
395 * Reports XPointer Warnings
396 *
397 */
398 private void reportWarning(String key, Object[] arguments)
399 throws XNIException {
400 fXPointerErrorReporter.reportError(
401 XPointerMessageFormatter.XPOINTER_DOMAIN, key, arguments,
402 XMLErrorReporter.SEVERITY_WARNING);
403 }
404
405 /**
406 * Initializes error handling objects
407 *
408 */
409 protected void initErrorReporter() {
410 if (fXPointerErrorReporter == null) {
411 fXPointerErrorReporter = new XMLErrorReporter();
412 }
413 if (fErrorHandler == null) {
414 fErrorHandler = new XPointerErrorHandler();
415 }
416 /*
417 fXPointerErrorReporter.setProperty(Constants.XERCES_PROPERTY_PREFIX
418 + Constants.ERROR_HANDLER_PROPERTY, fErrorHandler);
419 */
420 fXPointerErrorReporter.putMessageFormatter(
421 XPointerMessageFormatter.XPOINTER_DOMAIN,
422 new XPointerMessageFormatter());
423 }
424
425 /**
426 * Initializes the XPointer Processor;
427 */
428 protected void init() {
429 fXPointerParts.clear();
430 fXPointerPart = null;
431 fFoundMatchingPtrPart = false;
432 fIsXPointerResolved = false;
433 //fFixupBase = false;
434 //fFixupLang = false;
435
436 initErrorReporter();
437 }
438
439 /**
440 * Returns an ArrayList of XPointerPart objects
441 *
442 * @return An ArrayList of XPointerPart objects.
443 */
444 public ArrayList<XPointerPart> getPointerParts() {
445 return fXPointerParts;
446 }
447
448 /**
449 * List of XPointer Framework tokens.
450 *
451 * @xerces.internal
452 *
453 */
454 private final class Tokens {
455
456 /**
457 * XPointer Framework tokens
458 * [1] Pointer ::= Shorthand | SchemeBased
459 * [2] Shorthand ::= NCName
460 * [3] SchemeBased ::= PointerPart (S? PointerPart)*
461 * [4] PointerPart ::= SchemeName '(' SchemeData ')'
462 * [5] SchemeName ::= QName
463 * [6] SchemeData ::= EscapedData*
464 * [7] EscapedData ::= NormalChar | '^(' | '^)' | '^^' | '(' SchemeData ')'
465 * [8] NormalChar ::= UnicodeChar - [()^]
466 * [9] UnicodeChar ::= [#x0-#x10FFFF]
467 *
468 */
469 private static final int XPTRTOKEN_OPEN_PAREN = 0,
470 XPTRTOKEN_CLOSE_PAREN = 1, XPTRTOKEN_SHORTHAND = 2,
471 XPTRTOKEN_SCHEMENAME = 3, XPTRTOKEN_SCHEMEDATA = 4;
472
473 // Token names
474 private final String[] fgTokenNames = { "XPTRTOKEN_OPEN_PAREN",
475 "XPTRTOKEN_CLOSE_PAREN", "XPTRTOKEN_SHORTHAND",
476 "XPTRTOKEN_SCHEMENAME", "XPTRTOKEN_SCHEMEDATA" };
477
478 // Token count
479 private static final int INITIAL_TOKEN_COUNT = 1 << 8;
480
481 private int[] fTokens = new int[INITIAL_TOKEN_COUNT];
482
483 private int fTokenCount = 0;
484
485 // Current token position
486 private int fCurrentTokenIndex;
487
488 private SymbolTable fSymbolTable;
489
490 private HashMap<Integer, String> fTokenNames = new HashMap<>();
491
492 /**
493 * Constructor
494 *
495 * @param symbolTable SymbolTable
496 */
497 private Tokens(SymbolTable symbolTable) {
498 fSymbolTable = symbolTable;
499
500 fTokenNames.put(new Integer(XPTRTOKEN_OPEN_PAREN),
501 "XPTRTOKEN_OPEN_PAREN");
502 fTokenNames.put(new Integer(XPTRTOKEN_CLOSE_PAREN),
503 "XPTRTOKEN_CLOSE_PAREN");
504 fTokenNames.put(new Integer(XPTRTOKEN_SHORTHAND),
505 "XPTRTOKEN_SHORTHAND");
506 fTokenNames.put(new Integer(XPTRTOKEN_SCHEMENAME),
507 "XPTRTOKEN_SCHEMENAME");
508 fTokenNames.put(new Integer(XPTRTOKEN_SCHEMEDATA),
509 "XPTRTOKEN_SCHEMEDATA");
510 }
511
512 /**
513 * Returns the token String
514 * @param token The index of the token
515 * @return String The token string
516 */
517 private String getTokenString(int token) {
518 return fTokenNames.get(new Integer(token));
519 }
520
521 /**
522 * Add the specified string as a token
523 *
524 * @param token The token string
525 */
526 private void addToken(String tokenStr) {
527 if (!fTokenNames.containsValue(tokenStr)) {
528 Integer tokenInt = new Integer(fTokenNames.size());
529 fTokenNames.put(tokenInt, tokenStr);
530 addToken(tokenInt.intValue());
531 }
532 }
533
534 /**
535 * Add the specified int token
536 *
537 * @param token The int specifying the token
538 */
539 private void addToken(int token) {
540 try {
541 fTokens[fTokenCount] = token;
542 } catch (ArrayIndexOutOfBoundsException ex) {
543 int[] oldList = fTokens;
544 fTokens = new int[fTokenCount << 1];
545 System.arraycopy(oldList, 0, fTokens, 0, fTokenCount);
546 fTokens[fTokenCount] = token;
547 }
548 fTokenCount++;
549 }
550
551 /**
552 * Resets the current position to the head of the token list.
553 */
554 private void rewind() {
555 fCurrentTokenIndex = 0;
556 }
557
558 /**
559 * Returns true if the {@link #getNextToken()} method
560 * returns a valid token.
561 */
562 private boolean hasMore() {
563 return fCurrentTokenIndex < fTokenCount;
564 }
565
566 /**
567 * Obtains the token at the current position, then advance
568 * the current position by one.
569 *
570 * throws If there's no such next token, this method throws
571 * <tt>new XNIException("XPointerProcessingError");</tt>.
572 */
573 private int nextToken() throws XNIException {
574 if (fCurrentTokenIndex == fTokenCount) {
575 reportError("XPointerProcessingError", null);
576 }
577 return fTokens[fCurrentTokenIndex++];
578 }
579
580 /**
581 * Obtains the token at the current position, without advancing
582 * the current position.
583 *
584 * If there's no such next token, this method throws
585 * <tt>new XNIException("XPointerProcessingError");</tt>.
586 */
587 private int peekToken() throws XNIException {
588 if (fCurrentTokenIndex == fTokenCount) {
589 reportError("XPointerProcessingError", null);
590 }
591 return fTokens[fCurrentTokenIndex];
592 }
593
594 /**
595 * Obtains the token at the current position as a String.
596 *
597 * If there's no current token or if the current token
598 * is not a string token, this method throws
599 * If there's no such next token, this method throws
600 * <tt>new XNIException("XPointerProcessingError");</tt>.
601 */
602 private String nextTokenAsString() throws XNIException {
603 String tokenStrint = getTokenString(nextToken());
604 if (tokenStrint == null) {
605 reportError("XPointerProcessingError", null);
606 }
607 return tokenStrint;
608 }
609 }
610
611 /**
612 *
613 * The XPointer expression scanner. Scans the XPointer framework expression.
614 *
615 * @xerces.internal
616 *
617 */
618 private class Scanner {
619
620 /**
621 * 7-bit ASCII subset
622 *
623 * 0 1 2 3 4 5 6 7 8 9 A B C D E F
624 * 0, 0, 0, 0, 0, 0, 0, 0, 0, HT, LF, 0, 0, CR, 0, 0, // 0
625 * 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1
626 * SP, !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, // 2
627 * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, :, ;, <, =, >, ?, // 3
628 * @, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, // 4
629 * P, Q, R, S, T, U, V, W, X, Y, Z, [, \, ], ^, _, // 5
630 * `, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, // 6
631 * p, q, r, s, t, u, v, w, x, y, z, {, |, }, ~, DEL // 7
632 */
633 private static final byte CHARTYPE_INVALID = 0, // invalid XML character
634 CHARTYPE_OTHER = 1, // not special - one of "#%&;?\`{}~" or DEL
635 CHARTYPE_WHITESPACE = 2, // one of "\t\n\r " (0x09, 0x0A, 0x0D, 0x20)
636 CHARTYPE_CARRET = 3, // ^
637 CHARTYPE_OPEN_PAREN = 4, // '(' (0x28)
638 CHARTYPE_CLOSE_PAREN = 5, // ')' (0x29)
639 CHARTYPE_MINUS = 6, // '-' (0x2D)
640 CHARTYPE_PERIOD = 7, // '.' (0x2E)
641 CHARTYPE_SLASH = 8, // '/' (0x2F)
642 CHARTYPE_DIGIT = 9, // '0'-'9' (0x30 to 0x39)
643 CHARTYPE_COLON = 10, // ':' (0x3A)
644 CHARTYPE_EQUAL = 11, // '=' (0x3D)
645 CHARTYPE_LETTER = 12, // 'A'-'Z' or 'a'-'z' (0x41 to 0x5A and 0x61 to 0x7A)
646 CHARTYPE_UNDERSCORE = 13, // '_' (0x5F)
647 CHARTYPE_NONASCII = 14; // Non-ASCII Unicode codepoint (>= 0x80)
648
649 private final byte[] fASCIICharMap = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2,
650 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
651 2, 1, 1, 1, 1, 1, 1, 1, 4, 5, 1, 1, 1, 6, 7, 8, 9, 9, 9, 9, 9,
652 9, 9, 9, 9, 9, 10, 1, 1, 11, 1, 1, 1, 12, 12, 12, 12, 12, 12,
653 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
654 12, 12, 12, 12, 1, 1, 1, 3, 13, 1, 12, 12, 12, 12, 12, 12, 12,
655 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
656 12, 12, 12, 1, 1, 1, 1, 1 };
657
658 //
659 // Data
660 //
661 /** Symbol table. */
662 private SymbolTable fSymbolTable;
663
664 /**
665 * Constructs an XPointer Framework expression scanner.
666 *
667 * @param symbolTable SymbolTable
668 */
669 private Scanner(SymbolTable symbolTable) {
670 // save pool and tokens
671 fSymbolTable = symbolTable;
672
673 } // <init>(SymbolTable)
674
675 /**
676 * Scans the XPointer Expression
677 *
678 */
679 private boolean scanExpr(SymbolTable symbolTable, Tokens tokens,
680 String data, int currentOffset, int endOffset)
681 throws XNIException {
682
683 int ch;
684 int openParen = 0;
685 int closeParen = 0;
686 int nameOffset, dataOffset;
687 boolean isQName = false;
688 String name = null;
689 String prefix = null;
690 String schemeData = null;
691 StringBuffer schemeDataBuff = new StringBuffer();
692
693 while (true) {
694
695 if (currentOffset == endOffset) {
696 break;
697 }
698 ch = data.charAt(currentOffset);
699
700 //
701 while (ch == ' ' || ch == 0x0A || ch == 0x09 || ch == 0x0D) {
702 if (++currentOffset == endOffset) {
703 break;
704 }
705 ch = data.charAt(currentOffset);
706 }
707 if (currentOffset == endOffset) {
708 break;
709 }
710
711 //
712 // [1] Pointer ::= Shorthand | SchemeBased
713 // [2] Shorthand ::= NCName
714 // [3] SchemeBased ::= PointerPart (S? PointerPart)*
715 // [4] PointerPart ::= SchemeName '(' SchemeData ')'
716 // [5] SchemeName ::= QName
717 // [6] SchemeData ::= EscapedData*
718 // [7] EscapedData ::= NormalChar | '^(' | '^)' | '^^' | '(' SchemeData ')'
719 // [8] NormalChar ::= UnicodeChar - [()^]
720 // [9] UnicodeChar ::= [#x0-#x10FFFF]
721 // [?] QName ::= (NCName ':')? NCName
722 // [?] NCName ::= (Letter | '_') (NCNameChar)*
723 // [?] NCNameChar ::= Letter | Digit | '.' | '-' | '_' (ascii subset of 'NCNameChar')
724 // [?] Letter ::= [A-Za-z] (ascii subset of 'Letter')
725 // [?] Digit ::= [0-9] (ascii subset of 'Digit')
726 //
727 byte chartype = (ch >= 0x80) ? CHARTYPE_NONASCII
728 : fASCIICharMap[ch];
729
730 switch (chartype) {
731
732 case CHARTYPE_OPEN_PAREN: // '('
733 addToken(tokens, Tokens.XPTRTOKEN_OPEN_PAREN);
734 openParen++;
735 ++currentOffset;
736 break;
737
738 case CHARTYPE_CLOSE_PAREN: // ')'
739 addToken(tokens, Tokens.XPTRTOKEN_CLOSE_PAREN);
740 closeParen++;
741 ++currentOffset;
742 break;
743
744 case CHARTYPE_CARRET:
745 case CHARTYPE_COLON:
746 case CHARTYPE_DIGIT:
747 case CHARTYPE_EQUAL:
748 case CHARTYPE_LETTER:
749 case CHARTYPE_MINUS:
750 case CHARTYPE_NONASCII:
751 case CHARTYPE_OTHER:
752 case CHARTYPE_PERIOD:
753 case CHARTYPE_SLASH:
754 case CHARTYPE_UNDERSCORE:
755 case CHARTYPE_WHITESPACE:
756 // Scanning SchemeName | Shorthand
757 if (openParen == 0) {
758 nameOffset = currentOffset;
759 currentOffset = scanNCName(data, endOffset,
760 currentOffset);
761
762 if (currentOffset == nameOffset) {
763 reportError("InvalidShortHandPointer",
764 new Object[] { data });
765 return false;
766 }
767
768 if (currentOffset < endOffset) {
769 ch = data.charAt(currentOffset);
770 } else {
771 ch = -1;
772 }
773
774 name = symbolTable.addSymbol(data.substring(nameOffset,
775 currentOffset));
776 prefix = XMLSymbols.EMPTY_STRING;
777
778 // The name is a QName => a SchemeName
779 if (ch == ':') {
780 if (++currentOffset == endOffset) {
781 return false;
782 }
783
784 ch = data.charAt(currentOffset);
785 prefix = name;
786 nameOffset = currentOffset;
787 currentOffset = scanNCName(data, endOffset,
788 currentOffset);
789
790 if (currentOffset == nameOffset) {
791 return false;
792 }
793
794 if (currentOffset < endOffset) {
795 ch = data.charAt(currentOffset);
796 } else {
797 ch = -1;
798 }
799
800 isQName = true;
801 name = symbolTable.addSymbol(data.substring(
802 nameOffset, currentOffset));
803 }
804
805 // REVISIT:
806 if (currentOffset != endOffset) {
807 addToken(tokens, Tokens.XPTRTOKEN_SCHEMENAME);
808 tokens.addToken(prefix);
809 tokens.addToken(name);
810 isQName = false;
811 } else if (currentOffset == endOffset) {
812 // NCName => Shorthand
813 addToken(tokens, Tokens.XPTRTOKEN_SHORTHAND);
814 tokens.addToken(name);
815 isQName = false;
816 }
817
818 // reset open/close paren for the next pointer part
819 closeParen = 0;
820
821 break;
822
823 } else if (openParen > 0 && closeParen == 0 && name != null) {
824 // Scanning SchemeData
825 dataOffset = currentOffset;
826 currentOffset = scanData(data, schemeDataBuff,
827 endOffset, currentOffset);
828
829 if (currentOffset == dataOffset) {
830 reportError("InvalidSchemeDataInXPointer",
831 new Object[] { data });
832 return false;
833 }
834
835 if (currentOffset < endOffset) {
836 ch = data.charAt(currentOffset);
837 } else {
838 ch = -1;
839 }
840
841 schemeData = symbolTable.addSymbol(schemeDataBuff
842 .toString());
843 addToken(tokens, Tokens.XPTRTOKEN_SCHEMEDATA);
844 tokens.addToken(schemeData);
845
846 // reset open/close paren for the next pointer part
847 openParen = 0;
848 schemeDataBuff.delete(0, schemeDataBuff.length());
849
850 } else {
851 // ex. schemeName()
852 // Should we throw an exception with a more suitable message instead??
853 return false;
854 }
855 }
856 } // end while
857 return true;
858 }
859
860 /**
861 * Scans a NCName.
862 * From Namespaces in XML
863 * [5] NCName ::= (Letter | '_') (NCNameChar)*
864 * [6] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender
865 *
866 * @param data A String containing the XPointer expression
867 * @param endOffset The int XPointer expression length
868 * @param currentOffset An int representing the current position of the XPointer expression pointer
869 */
870 private int scanNCName(String data, int endOffset, int currentOffset) {
871 int ch = data.charAt(currentOffset);
872 if (ch >= 0x80) {
873 if (!XMLChar.isNameStart(ch)) {
874 return currentOffset;
875 }
876 } else {
877 byte chartype = fASCIICharMap[ch];
878 if (chartype != CHARTYPE_LETTER
879 && chartype != CHARTYPE_UNDERSCORE) {
880 return currentOffset;
881 }
882 }
883
884 //while (currentOffset++ < endOffset) {
885 while (++currentOffset < endOffset) {
886 ch = data.charAt(currentOffset);
887 if (ch >= 0x80) {
888 if (!XMLChar.isName(ch)) {
889 break;
890 }
891 } else {
892 byte chartype = fASCIICharMap[ch];
893 if (chartype != CHARTYPE_LETTER
894 && chartype != CHARTYPE_DIGIT
895 && chartype != CHARTYPE_PERIOD
896 && chartype != CHARTYPE_MINUS
897 && chartype != CHARTYPE_UNDERSCORE) {
898 break;
899 }
900 }
901 }
902 return currentOffset;
903 }
904
905 /**
906 * Scans the SchemeData.
907 * [6] SchemeData ::= EscapedData*
908 * [7] EscapedData ::= NormalChar | '^(' | '^)' | '^^' | '(' SchemeData ')'
909 * [8] NormalChar ::= UnicodeChar - [()^]
910 * [9] UnicodeChar ::= [#x0-#x10FFFF]
911 *
912 */
913 private int scanData(String data, StringBuffer schemeData,
914 int endOffset, int currentOffset) {
915 while (true) {
916
917 if (currentOffset == endOffset) {
918 break;
919 }
920
921 int ch = data.charAt(currentOffset);
922 byte chartype = (ch >= 0x80) ? CHARTYPE_NONASCII
923 : fASCIICharMap[ch];
924
925 if (chartype == CHARTYPE_OPEN_PAREN) {
926 schemeData.append(ch);
927 //schemeData.append(Tokens.XPTRTOKEN_OPEN_PAREN);
928 currentOffset = scanData(data, schemeData, endOffset,
929 ++currentOffset);
930 if (currentOffset == endOffset) {
931 return currentOffset;
932 }
933
934 ch = data.charAt(currentOffset);
935 chartype = (ch >= 0x80) ? CHARTYPE_NONASCII
936 : fASCIICharMap[ch];
937
938 if (chartype != CHARTYPE_CLOSE_PAREN) {
939 return endOffset;
940 }
941 schemeData.append((char) ch);
942 ++currentOffset;//
943
944 } else if (chartype == CHARTYPE_CLOSE_PAREN) {
945 return currentOffset;
946
947 } else if (chartype == CHARTYPE_CARRET) {
948 ch = data.charAt(++currentOffset);
949 chartype = (ch >= 0x80) ? CHARTYPE_NONASCII
950 : fASCIICharMap[ch];
951
952 if (chartype != CHARTYPE_CARRET
953 && chartype != CHARTYPE_OPEN_PAREN
954 && chartype != CHARTYPE_CLOSE_PAREN) {
955 break;
956 }
957 schemeData.append((char) ch);
958 ++currentOffset;
959
960 } else {
961 schemeData.append((char) ch);
962 ++currentOffset;//
963 }
964 }
965
966 return currentOffset;
967 }
968
969 //
970 // Protected methods
971 //
972
973 /**
974 * This method adds the specified token to the token list. By
975 * default, this method allows all tokens. However, subclasses
976 * of the XPathExprScanner can override this method in order
977 * to disallow certain tokens from being used in the scanned
978 * XPath expression. This is a convenient way of allowing only
979 * a subset of XPath.
980 */
981 protected void addToken(Tokens tokens, int token) throws XNIException {
982 tokens.addToken(token);
983 } // addToken(int)
984
985 } // class Scanner
986
987 // ************************************************************************
988 // Overridden XMLDocumentHandler methods
989 // ************************************************************************
990 /**
991 * If the comment is a child of a matched element, then pass else return.
992 *
993 * @param text The text in the comment.
994 * @param augs Additional information that may include infoset augmentations
995 *
996 * @exception XNIException
997 * Thrown by application to signal an error.
998 */
999 public void comment(XMLString text, Augmentations augs) throws XNIException {
1000 if (!isChildFragmentResolved()) {
1001 return;
1002 }
1003 super.comment(text, augs);
1004 }
1005
1006 /**
1007 * A processing instruction. Processing instructions consist of a
1008 * target name and, optionally, text data. The data is only meaningful
1009 * to the application.
1010 * <p>
1011 * Typically, a processing instruction's data will contain a series
1012 * of pseudo-attributes. These pseudo-attributes follow the form of
1013 * element attributes but are <strong>not</strong> parsed or presented
1014 * to the application as anything other than text. The application is
1015 * responsible for parsing the data.
1016 *
1017 * @param target The target.
1018 * @param data The data or null if none specified.
1019 * @param augs Additional information that may include infoset augmentations
1020 *
1021 * @exception XNIException
1022 * Thrown by handler to signal an error.
1023 */
1024 public void processingInstruction(String target, XMLString data,
1025 Augmentations augs) throws XNIException {
1026 if (!isChildFragmentResolved()) {
1027 return;
1028 }
1029 super.processingInstruction(target, data, augs);
1030 }
1031
1032 /**
1033 * The start of an element.
1034 *
1035 * @param element The name of the element.
1036 * @param attributes The element attributes.
1037 * @param augs Additional information that may include infoset augmentations
1038 *
1039 * @exception XNIException
1040 * Thrown by handler to signal an error.
1041 */
1042 public void startElement(QName element, XMLAttributes attributes,
1043 Augmentations augs) throws XNIException {
1044 if (!resolveXPointer(element, attributes, augs,
1045 XPointerPart.EVENT_ELEMENT_START)) {
1046
1047 // xml:base and xml:lang processing
1048 if (fFixupBase) {
1049 processXMLBaseAttributes(attributes);
1050 }
1051 if (fFixupLang) {
1052 processXMLLangAttributes(attributes);
1053 }
1054
1055 // set the context invalid if the element till an element from the result infoset is included
1056 fNamespaceContext.setContextInvalid();
1057
1058 return;
1059 }
1060 super.startElement(element, attributes, augs);
1061 }
1062
1063 /**
1064 * An empty element.
1065 *
1066 * @param element The name of the element.
1067 * @param attributes The element attributes.
1068 * @param augs Additional information that may include infoset augmentations
1069 *
1070 * @exception XNIException
1071 * Thrown by handler to signal an error.
1072 */
1073 public void emptyElement(QName element, XMLAttributes attributes,
1074 Augmentations augs) throws XNIException {
1075 if (!resolveXPointer(element, attributes, augs,
1076 XPointerPart.EVENT_ELEMENT_EMPTY)) {
1077 // xml:base and xml:lang processing
1078 if (fFixupBase) {
1079 processXMLBaseAttributes(attributes);
1080 }
1081 if (fFixupLang) {
1082 processXMLLangAttributes(attributes);
1083 }
1084 // no need to restore restoreBaseURI() for xml:base and xml:lang processing
1085
1086 // set the context invalid if the element till an element from the result infoset is included
1087 fNamespaceContext.setContextInvalid();
1088 return;
1089 }
1090 super.emptyElement(element, attributes, augs);
1091 }
1092
1093 /**
1094 * Character content.
1095 *
1096 * @param text The content.
1097 * @param augs Additional information that may include infoset augmentations
1098 *
1099 * @exception XNIException
1100 * Thrown by handler to signal an error.
1101 */
1102 public void characters(XMLString text, Augmentations augs)
1103 throws XNIException {
1104 if (!isChildFragmentResolved()) {
1105 return;
1106 }
1107 super.characters(text, augs);
1108 }
1109
1110 /**
1111 * Ignorable whitespace. For this method to be called, the document
1112 * source must have some way of determining that the text containing
1113 * only whitespace characters should be considered ignorable. For
1114 * example, the validator can determine if a length of whitespace
1115 * characters in the document are ignorable based on the element
1116 * content model.
1117 *
1118 * @param text The ignorable whitespace.
1119 * @param augs Additional information that may include infoset augmentations
1120 *
1121 * @exception XNIException
1122 * Thrown by handler to signal an error.
1123 */
1124 public void ignorableWhitespace(XMLString text, Augmentations augs)
1125 throws XNIException {
1126 if (!isChildFragmentResolved()) {
1127 return;
1128 }
1129 super.ignorableWhitespace(text, augs);
1130 }
1131
1132 /**
1133 * The end of an element.
1134 *
1135 * @param element The name of the element.
1136 * @param augs Additional information that may include infoset augmentations
1137 *
1138 * @exception XNIException
1139 * Thrown by handler to signal an error.
1140 */
1141 public void endElement(QName element, Augmentations augs)
1142 throws XNIException {
1143 if (!resolveXPointer(element, null, augs,
1144 XPointerPart.EVENT_ELEMENT_END)) {
1145
1146 // no need to restore restoreBaseURI() for xml:base and xml:lang processing
1147 return;
1148 }
1149 super.endElement(element, augs);
1150 }
1151
1152 /**
1153 * The start of a CDATA section.
1154 *
1155 * @param augs Additional information that may include infoset augmentations
1156 *
1157 * @exception XNIException
1158 * Thrown by handler to signal an error.
1159 */
1160 public void startCDATA(Augmentations augs) throws XNIException {
1161 if (!isChildFragmentResolved()) {
1162 return;
1163 }
1164 super.startCDATA(augs);
1165 }
1166
1167 /**
1168 * The end of a CDATA section.
1169 *
1170 * @param augs Additional information that may include infoset augmentations
1171 *
1172 * @exception XNIException
1173 * Thrown by handler to signal an error.
1174 */
1175 public void endCDATA(Augmentations augs) throws XNIException {
1176 if (!isChildFragmentResolved()) {
1177 return;
1178 }
1179 super.endCDATA(augs);
1180 }
1181
1182 // ************************************************************************
1183 // Overridden XMLComponent methods
1184 // ************************************************************************
1185 /**
1186 * <p>
1187 * Sets the value of a property. This method is called by the component
1188 * manager any time after reset when a property changes value.
1189 * </p>
1190 * <strong>Note:</strong> Components should silently ignore properties
1191 * that do not affect the operation of the component.
1192 *
1193 * @param propertyId The property identifier.
1194 * @param value The value of the property.
1195 *
1196 * @throws XMLConfigurationException Thrown for configuration error.
1197 * In general, components should
1198 * only throw this exception if
1199 * it is <strong>really</strong>
1200 * a critical error.
1201 */
1202 public void setProperty(String propertyId, Object value)
1203 throws XMLConfigurationException {
1204
1205 // Error reporter
1206 if (propertyId == Constants.XERCES_PROPERTY_PREFIX
1207 + Constants.ERROR_REPORTER_PROPERTY) {
1208 if (value != null) {
1209 fXPointerErrorReporter = (XMLErrorReporter) value;
1210 } else {
1211 fXPointerErrorReporter = null;
1212 }
1213 }
1214
1215 // Error handler
1216 if (propertyId == Constants.XERCES_PROPERTY_PREFIX
1217 + Constants.ERROR_HANDLER_PROPERTY) {
1218 if (value != null) {
1219 fErrorHandler = (XMLErrorHandler) value;
1220 } else {
1221 fErrorHandler = null;
1222 }
1223 }
1224
1225 // xml:lang
1226 if (propertyId == Constants.XERCES_FEATURE_PREFIX
1227 + Constants.XINCLUDE_FIXUP_LANGUAGE_FEATURE) {
1228 if (value != null) {
1229 fFixupLang = ((Boolean)value).booleanValue();
1230 } else {
1231 fFixupLang = false;
1232 }
1233 }
1234
1235 // xml:base
1236 if (propertyId == Constants.XERCES_FEATURE_PREFIX
1237 + Constants.XINCLUDE_FIXUP_BASE_URIS_FEATURE) {
1238 if (value != null) {
1239 fFixupBase = ((Boolean)value).booleanValue();
1240 } else {
1241 fFixupBase = false;
1242 }
1243 }
1244
1245 //
1246 if (propertyId == Constants.XERCES_PROPERTY_PREFIX
1247 + Constants.NAMESPACE_CONTEXT_PROPERTY) {
1248 fNamespaceContext = (XIncludeNamespaceSupport) value;
1249 }
1250
1251 super.setProperty(propertyId, value);
1252 }
1253
1254 }