Added source for ByteEdit

src/org/fife/ui/rsyntaxtextarea/ParserManager.java

@@ -0,0 +1,829 @@
+/*
+ * 09/26/2005
+ *
+ * ParserManager.java - Manages the parsing of an RSyntaxTextArea's document,
+ * if necessary.
+ *
+ * This library is distributed under a modified BSD license.  See the included
+ * RSyntaxTextArea.License.txt file for details.
+ */
+package org.fife.ui.rsyntaxtextarea;
+
+import java.awt.Color;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.net.URL;
+import java.security.AccessControlException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.swing.Timer;
+import javax.swing.ToolTipManager;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.event.HyperlinkEvent;
+import javax.swing.event.HyperlinkListener;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+import javax.swing.text.Element;
+import javax.swing.text.Position;
+
+import org.fife.ui.rsyntaxtextarea.parser.ParseResult;
+import org.fife.ui.rsyntaxtextarea.parser.Parser;
+import org.fife.ui.rsyntaxtextarea.parser.ParserNotice;
+import org.fife.ui.rsyntaxtextarea.parser.ToolTipInfo;
+import org.fife.ui.rtextarea.RDocument;
+import org.fife.ui.rtextarea.RTextAreaHighlighter.HighlightInfo;
+
+
+
+/**
+ * Manages running a parser object for an <code>RSyntaxTextArea</code>.
+ *
+ * @author Robert Futrell
+ * @version 0.9
+ */
+class ParserManager implements DocumentListener, ActionListener,
+								HyperlinkListener, PropertyChangeListener {
+
+	private RSyntaxTextArea textArea;
+	private List<Parser> parsers;
+	private Timer timer;
+	private boolean running;
+	private Parser parserForTip;
+	private Position firstOffsetModded;
+	private Position lastOffsetModded;
+
+	/**
+	 * Mapping of notices to their highlights in the editor.  Can't use a Map
+	 * since parsers could return two <code>ParserNotice</code>s that compare
+	 * equally via <code>equals()</code>.  Real-world example:  The Perl
+	 * compiler will return 2+ identical error messages if the same error is
+	 * committed in a single line more than once.
+	 */
+	private List<NoticeHighlightPair> noticeHighlightPairs;
+
+	/**
+	 * Painter used to underline errors.
+	 */
+	private SquiggleUnderlineHighlightPainter parserErrorHighlightPainter =
+						new SquiggleUnderlineHighlightPainter(Color.RED);
+
+	/**
+	 * If this system property is set to <code>true</code>, debug messages
+	 * will be printed to stdout to help diagnose parsing issues.
+	 */
+	private static final String PROPERTY_DEBUG_PARSING = "rsta.debugParsing";
+
+	/**
+	 * Whether to print debug messages while running parsers.
+	 */
+	private static final boolean DEBUG_PARSING;
+
+	/**
+	 * The default delay between the last key press and when the document
+	 * is parsed, in milliseconds.
+	 */
+	private static final int DEFAULT_DELAY_MS		= 1250;
+
+
+	/**
+	 * Constructor.
+	 *
+	 * @param textArea The text area whose document the parser will be
+	 *        parsing.
+	 */
+	ParserManager(RSyntaxTextArea textArea) {
+		this(DEFAULT_DELAY_MS, textArea);
+	}
+
+
+	/**
+	 * Constructor.
+	 *
+	 * @param delay The delay between the last key press and when the document
+	 *        is parsed.
+	 * @param textArea The text area whose document the parser will be
+	 *        parsing.
+	 */
+	ParserManager(int delay, RSyntaxTextArea textArea) {
+		this.textArea = textArea;
+		textArea.getDocument().addDocumentListener(this);
+		textArea.addPropertyChangeListener("document", this);
+		parsers = new ArrayList<Parser>(1); // Usually small
+		timer = new Timer(delay, this);
+		timer.setRepeats(false);
+		running = true;
+	}
+
+
+	/**
+	 * Called when the timer fires (e.g. it's time to parse the document).
+	 *
+	 * @param e The event.
+	 */
+	@Override
+	public void actionPerformed(ActionEvent e) {
+
+		// Sanity check - should have >1 parser if event is fired.
+		int parserCount = getParserCount();
+		if (parserCount==0) {
+			return;
+		}
+
+		long begin = 0;
+		if (DEBUG_PARSING) {
+			begin = System.currentTimeMillis();
+		}
+
+		RSyntaxDocument doc = (RSyntaxDocument)textArea.getDocument();
+
+		Element root = doc.getDefaultRootElement();
+		int firstLine = firstOffsetModded==null ? 0 :
+			root.getElementIndex(firstOffsetModded.getOffset());
+		int lastLine = lastOffsetModded==null ? root.getElementCount()-1 :
+			root.getElementIndex(lastOffsetModded.getOffset());
+		firstOffsetModded = lastOffsetModded = null;
+		if (DEBUG_PARSING) {
+			System.out.println("[DEBUG]: Minimum lines to parse: " + firstLine + "-" + lastLine);
+		}
+
+		String style = textArea.getSyntaxEditingStyle();
+		doc.readLock();
+		try {
+			for (int i=0; i<parserCount; i++) {
+				Parser parser = getParser(i);
+				if (parser.isEnabled()) {
+					ParseResult res = parser.parse(doc, style);
+					addParserNoticeHighlights(res);
+				}
+				else {
+					clearParserNoticeHighlights(parser);
+				}
+			}
+			textArea.fireParserNoticesChange();
+		} finally {
+			doc.readUnlock();
+		}
+
+		if (DEBUG_PARSING) {
+			float time = (System.currentTimeMillis()-begin)/1000f;
+			System.out.println("Total parsing time: " + time + " seconds");
+		}
+
+	}
+
+
+	/**
+	 * Adds a parser for the text area.
+	 *
+	 * @param parser The new parser.  If this is <code>null</code>, nothing
+	 *        happens.
+	 * @see #getParser(int)
+	 * @see #removeParser(Parser)
+	 */
+	public void addParser(Parser parser) {
+		if (parser!=null && !parsers.contains(parser)) {
+			if (running) {
+				timer.stop();
+			}
+			parsers.add(parser);
+			if (parsers.size()==1) {
+				// Okay to call more than once.
+				ToolTipManager.sharedInstance().registerComponent(textArea);
+			}
+			if (running) {
+				timer.restart();
+			}
+		}
+	}
+
+
+	/**
+	 * Adds highlights for a list of parser notices.  Any current notices
+	 * from the same Parser, in the same parsed range, are removed.
+	 *
+	 * @param res The result of a parsing.
+	 * @see #clearParserNoticeHighlights()
+	 */
+	private void addParserNoticeHighlights(ParseResult res) {
+
+		// Parsers are supposed to return at least empty ParseResults, but
+		// we'll be defensive here.
+		if (res==null) {
+			return;
+		}
+
+		if (DEBUG_PARSING) {
+			System.out.println("[DEBUG]: Adding parser notices from " +
+								res.getParser());
+		}
+
+		if (noticeHighlightPairs==null) {
+			noticeHighlightPairs = new ArrayList<NoticeHighlightPair>();
+		}
+
+		removeParserNotices(res);
+
+		List<ParserNotice> notices = res.getNotices();
+		if (notices.size()>0) { // Guaranteed non-null
+
+			RSyntaxTextAreaHighlighter h = (RSyntaxTextAreaHighlighter)
+													textArea.getHighlighter();
+
+			for (ParserNotice notice : notices) {
+				if (DEBUG_PARSING) {
+					System.out.println("[DEBUG]: ... adding: " + notice);
+				}
+				try {
+					HighlightInfo highlight = null;
+					if (notice.getShowInEditor()) {
+						highlight = h.addParserHighlight(notice,
+											parserErrorHighlightPainter);
+					}
+					noticeHighlightPairs.add(new NoticeHighlightPair(notice, highlight));
+				} catch (BadLocationException ble) { // Never happens
+					ble.printStackTrace();
+				}
+			}
+
+		}
+
+		if (DEBUG_PARSING) {
+			System.out.println("[DEBUG]: Done adding parser notices from " +
+								res.getParser());
+		}
+
+	}
+
+
+	/**
+	 * Called when the document is modified.
+	 *
+	 * @param e The document event.
+	 */
+	@Override
+	public void changedUpdate(DocumentEvent e) {
+	}
+
+
+	private void clearParserNoticeHighlights() {
+		RSyntaxTextAreaHighlighter h = (RSyntaxTextAreaHighlighter)
+											textArea.getHighlighter();
+		if (h!=null) {
+			h.clearParserHighlights();
+		}
+		if (noticeHighlightPairs!=null) {
+			noticeHighlightPairs.clear();
+		}
+	}
+
+
+	/**
+	 * Removes all parser notice highlights for a specific parser.
+	 *
+	 * @param parser The parser whose highlights to remove.
+	 */
+	private void clearParserNoticeHighlights(Parser parser) {
+		RSyntaxTextAreaHighlighter h = (RSyntaxTextAreaHighlighter)
+											textArea.getHighlighter();
+		if (h!=null) {
+			h.clearParserHighlights(parser);
+		}
+		if (noticeHighlightPairs!=null) {
+			Iterator<NoticeHighlightPair> i=noticeHighlightPairs.iterator();
+			while (i.hasNext()) {
+				NoticeHighlightPair pair = i.next();
+				if (pair.notice.getParser()==parser) {
+					i.remove();
+				}
+			}
+		}
+	}
+
+
+	/**
+	 * Removes all parsers and any highlights they have created.
+	 *
+	 * @see #addParser(Parser)
+	 */
+	public void clearParsers() {
+		timer.stop();
+		clearParserNoticeHighlights();
+		parsers.clear();
+		textArea.fireParserNoticesChange();
+	}
+
+
+	/**
+	 * Forces the given {@link Parser} to re-parse the content of this text
+	 * area.<p>
+	 *
+	 * This method can be useful when a <code>Parser</code> can be configured
+	 * as to what notices it returns.  For example, if a Java language parser
+	 * can be configured to set whether no serialVersionUID is a warning,
+	 * error, or ignored, this method can be called after changing the expected
+	 * notice type to have the document re-parsed.
+	 *
+	 * @param parser The index of the <code>Parser</code> to re-run.
+	 * @see #getParser(int)
+	 */
+	public void forceReparsing(int parser) {
+		Parser p = getParser(parser);
+		RSyntaxDocument doc = (RSyntaxDocument)textArea.getDocument();
+		String style = textArea.getSyntaxEditingStyle();
+		doc.readLock();
+		try {
+			if (p.isEnabled()) {
+				ParseResult res = p.parse(doc, style);
+				addParserNoticeHighlights(res);
+			}
+			else {
+				clearParserNoticeHighlights(p);
+			}
+			textArea.fireParserNoticesChange();
+		} finally {
+			doc.readUnlock();
+		}
+	}
+
+
+	/**
+	 * Returns the delay between the last "concurrent" edit and when the
+	 * document is re-parsed.
+	 *
+	 * @return The delay, in milliseconds.
+	 * @see #setDelay(int)
+	 */
+	public int getDelay() {
+		return timer.getDelay();
+	}
+
+
+	/**
+	 * Returns the specified parser.
+	 *
+	 * @param index The index of the parser.
+	 * @return The parser.
+	 * @see #getParserCount()
+	 * @see #addParser(Parser)
+	 * @see #removeParser(Parser)
+	 */
+	public Parser getParser(int index) {
+		return parsers.get(index);
+	}
+
+
+	/**
+	 * Returns the number of registered parsers.
+	 *
+	 * @return The number of registered parsers.
+	 */
+	public int getParserCount() {
+		return parsers.size();
+	}
+
+
+	/**
+	 * Returns a list of the current parser notices for this text area.
+	 * This method (like most Swing methods) should only be called on the
+	 * EDT.
+	 *
+	 * @return The list of notices.  This will be an empty list if there are
+	 *         none.
+	 */
+	public List<ParserNotice> getParserNotices() {
+		List<ParserNotice> notices = new ArrayList<ParserNotice>();
+		if (noticeHighlightPairs!=null) {
+			for (NoticeHighlightPair pair : noticeHighlightPairs) {
+				notices.add(pair.notice);
+			}
+		}
+		return notices;
+	}
+
+
+	/**
+	 * Returns the tool tip to display for a mouse event at the given
+	 * location.  This method is overridden to give a registered parser a
+	 * chance to display a tool tip (such as an error description when the
+	 * mouse is over an error highlight).
+	 *
+	 * @param e The mouse event.
+	 * @return The tool tip to display, and possibly a hyperlink event handler.
+	 */
+	public ToolTipInfo getToolTipText(MouseEvent e) {
+
+		String tip = null;
+		HyperlinkListener listener = null;
+		parserForTip = null;
+		Point p = e.getPoint();
+
+//		try {
+			int pos = textArea.viewToModel(p);
+			/*
+			Highlighter.Highlight[] highlights = textArea.getHighlighter().
+												getHighlights();
+			for (int i=0; i<highlights.length; i++) {
+				Highlighter.Highlight h = highlights[i];
+				//if (h instanceof ParserNoticeHighlight) {
+				//	ParserNoticeHighlight pnh = (ParserNoticeHighlight)h;
+					int start = h.getStartOffset();
+					int end = h.getEndOffset();
+					if (start<=pos && end>=pos) {
+						//return pnh.getMessage();
+						return textArea.getText(start, end-start);
+					}
+				//}
+			}
+			*/
+			if (noticeHighlightPairs!=null) {
+				for (NoticeHighlightPair pair : noticeHighlightPairs) {
+					ParserNotice notice = pair.notice;
+					if (noticeContainsPosition(notice, pos) &&
+							noticeContainsPointInView(notice, p)) {
+						tip = notice.getToolTipText();
+						parserForTip = notice.getParser();
+						if (parserForTip instanceof HyperlinkListener) {
+							listener = (HyperlinkListener)parserForTip;
+						}
+						break;
+					}
+				}
+			}
+//		} catch (BadLocationException ble) {
+//			ble.printStackTrace();	// Should never happen.
+//		}
+
+		URL imageBase = parserForTip==null ? null : parserForTip.getImageBase();
+		return new ToolTipInfo(tip, listener, imageBase);
+
+	}
+
+
+	/**
+	 * Called when the document is modified.
+	 *
+	 * @param e The document event.
+	 */
+	public void handleDocumentEvent(DocumentEvent e) {
+		if (running && parsers.size()>0) {
+			timer.restart();
+		}
+	}
+
+
+	/**
+	 * Called when the user clicks a hyperlink in a
+	 * {@link org.fife.ui.rsyntaxtextarea.focusabletip.FocusableTip}.
+	 *
+	 * @param e The event.
+	 */
+	@Override
+	public void hyperlinkUpdate(HyperlinkEvent e) {
+		if (parserForTip!=null && parserForTip.getHyperlinkListener()!=null) {
+			parserForTip.getHyperlinkListener().linkClicked(textArea, e);
+		}
+	}
+
+
+	/**
+	 * Called when the document is modified.
+	 *
+	 * @param e The document event.
+	 */
+	@Override
+	public void insertUpdate(DocumentEvent e) {
+
+		// Keep track of the first and last offset modified.  Some parsers are
+		// smart and will only re-parse this section of the file.
+		try {
+			int offs = e.getOffset();
+			if (firstOffsetModded==null || offs<firstOffsetModded.getOffset()) {
+				firstOffsetModded = e.getDocument().createPosition(offs);
+			}
+			offs = e.getOffset() + e.getLength();
+			if (lastOffsetModded==null || offs>lastOffsetModded.getOffset()) {
+				lastOffsetModded = e.getDocument().createPosition(offs);
+			}
+		} catch (BadLocationException ble) {
+			ble.printStackTrace(); // Shouldn't happen
+		}
+
+		handleDocumentEvent(e);
+
+	}
+
+
+	/**
+	 * Returns whether a parser notice contains the specified offset.
+	 *
+	 * @param notice The notice.
+	 * @param offs The offset.
+	 * @return Whether the notice contains the offset.
+	 */
+	private boolean noticeContainsPosition(ParserNotice notice, int offs){
+		if (notice.getKnowsOffsetAndLength()) {
+			return notice.containsPosition(offs);
+		}
+		Document doc = textArea.getDocument();
+		Element root = doc.getDefaultRootElement();
+		int line = notice.getLine();
+		if (line<0) { // Defensive against possible bad user-defined notices.
+			return false;
+		}
+		Element elem = root.getElement(line);
+		return elem != null && offs>=elem.getStartOffset() && offs<elem.getEndOffset();
+	}
+
+
+	/**
+	 * Since <code>viewToModel()</code> returns the <em>closest</em> model
+	 * position, and the position doesn't <em>necessarily</em> contain the
+	 * point passed in as an argument, this method checks whether the point is
+	 * indeed contained in the view rectangle for the specified offset.
+	 *
+	 * @param notice The parser notice.
+	 * @param p The point possibly contained in the view range of the
+	 *        parser notice.
+	 * @return Whether the parser notice actually contains the specified point
+	 *         in the view.
+	 */
+	private boolean noticeContainsPointInView(ParserNotice notice,
+			Point p) {
+
+		try {
+
+			int start, end;
+			if (notice.getKnowsOffsetAndLength()) {
+				start = notice.getOffset();
+				end = start + notice.getLength() - 1;
+			}
+			else {
+				Document doc = textArea.getDocument();
+				Element root = doc.getDefaultRootElement();
+				int line = notice.getLine();
+				// Defend against possible bad user-defined notices.
+				if (line<0) {
+					return false;
+				}
+				Element elem = root.getElement(line);
+				start = elem.getStartOffset();
+				end = elem.getEndOffset() - 1;
+			}
+
+			Rectangle r1 = textArea.modelToView(start);
+			Rectangle r2 = textArea.modelToView(end);
+			if (r1.y!=r2.y) {
+				// If the notice spans multiple lines, give them the benefit
+				// of the doubt.  This is only "wrong" if the user is in empty
+				// space "to the right" of the error marker when it ends at the
+				// end of a line anyway.
+				return true;
+			}
+
+			r1.y--; // Be a tiny bit lenient.
+			r1.height += 2; // Ditto
+			return p.x>=r1.x && p.x<(r2.x+r2.width) &&
+					p.y>=r1.y && p.y<(r1.y+r1.height);
+
+		} catch (BadLocationException ble) { // Never occurs
+			// Give them the benefit of the doubt, should 99% of the time be
+			// true anyway
+			return true;
+		}
+
+	}
+
+
+	/**
+	 * Called when a property we're interested in changes.
+	 *
+	 * @param e The property change event.
+	 */
+	@Override
+	public void propertyChange(PropertyChangeEvent e) {
+
+		String name = e.getPropertyName();
+
+		if ("document".equals(name)) {
+			// The document switched out from under us
+			RDocument old = (RDocument)e.getOldValue();
+			if (old != null) {
+				old.removeDocumentListener(this);
+			}
+			RDocument newDoc = (RDocument)e.getNewValue();
+			if (newDoc != null) {
+				newDoc.addDocumentListener(this);
+			}
+		}
+
+	}
+
+
+	/**
+	 * Removes a parser.
+	 *
+	 * @param parser The parser to remove.
+	 * @return Whether the parser was found.
+	 * @see #addParser(Parser)
+	 * @see #getParser(int)
+	 */
+	public boolean removeParser(Parser parser) {
+		removeParserNotices(parser);
+		boolean removed = parsers.remove(parser);
+		if (removed) {
+			textArea.fireParserNoticesChange();
+		}
+		return removed;
+	}
+
+
+	/**
+	 * Removes all parser notices (and clears highlights in the editor) from
+	 * a particular parser.
+	 *
+	 * @param parser The parser.
+	 */
+	private void removeParserNotices(Parser parser) {
+		if (noticeHighlightPairs!=null) {
+			RSyntaxTextAreaHighlighter h = (RSyntaxTextAreaHighlighter)
+												textArea.getHighlighter();
+			for (Iterator<NoticeHighlightPair> i=noticeHighlightPairs.iterator(); i.hasNext();) {
+				NoticeHighlightPair pair = i.next();
+				if (pair.notice.getParser()==parser && pair.highlight!=null) {
+					h.removeParserHighlight(pair.highlight);
+					i.remove();
+				}
+			}
+		}
+	}
+
+
+	/**
+	 * Removes any currently stored notices (and the corresponding highlights
+	 * from the editor) from the same Parser, and in the given line range,
+	 * as in the results.
+	 *
+	 * @param res The results.
+	 */
+	private void removeParserNotices(ParseResult res) {
+		if (noticeHighlightPairs!=null) {
+			RSyntaxTextAreaHighlighter h = (RSyntaxTextAreaHighlighter)
+												textArea.getHighlighter();
+			for (Iterator<NoticeHighlightPair> i=noticeHighlightPairs.iterator(); i.hasNext();) {
+				NoticeHighlightPair pair = i.next();
+				boolean removed = false;
+				if (shouldRemoveNotice(pair.notice, res)) {
+					if (pair.highlight!=null) {
+						h.removeParserHighlight(pair.highlight);
+					}
+					i.remove();
+					removed = true;
+				}
+				if (DEBUG_PARSING) {
+					String text = removed ? "[DEBUG]: ... notice removed: " :
+											"[DEBUG]: ... notice not removed: ";
+					System.out.println(text + pair.notice);
+				}
+			}
+
+		}
+
+	}
+
+
+	/**
+	 * Called when the document is modified.
+	 *
+	 * @param e The document event.
+	 */
+	@Override
+	public void removeUpdate(DocumentEvent e) {
+
+		// Keep track of the first and last offset modified.  Some parsers are
+		// smart and will only re-parse this section of the file.  Note that
+		// for removals, only the line at the removal start needs to be
+		// re-parsed.
+		try {
+			int offs = e.getOffset();
+			if (firstOffsetModded==null || offs<firstOffsetModded.getOffset()) {
+				firstOffsetModded = e.getDocument().createPosition(offs);
+			}
+			if (lastOffsetModded==null || offs>lastOffsetModded.getOffset()) {
+				lastOffsetModded = e.getDocument().createPosition(offs);
+			}
+		} catch (BadLocationException ble) { // Never happens
+			ble.printStackTrace();
+		}
+
+		handleDocumentEvent(e);
+
+	}
+
+
+	/**
+	 * Restarts parsing the document.
+	 *
+	 * @see #stopParsing()
+	 */
+	public void restartParsing() {
+		timer.restart();
+		running = true;
+	}
+
+
+	/**
+	 * Sets the delay between the last "concurrent" edit and when the document
+	 * is re-parsed.
+	 *
+	 * @param millis The new delay, in milliseconds.  This must be greater
+	 *        than <code>0</code>.
+	 * @see #getDelay()
+	 */
+	public void setDelay(int millis) {
+		if (running) {
+			timer.stop();
+		}
+		timer.setInitialDelay(millis);
+		timer.setDelay(millis);
+		if (running) {
+			timer.start();
+		}
+	}
+
+
+	/**
+	 * Returns whether a parser notice should be removed, based on a parse
+	 * result.
+	 *
+	 * @param notice The notice in question.
+	 * @param res The result.
+	 * @return Whether the notice should be removed.
+	 */
+	private boolean shouldRemoveNotice(ParserNotice notice,
+											ParseResult res) {
+
+		if (DEBUG_PARSING) {
+			System.out.println("[DEBUG]: ... ... shouldRemoveNotice " +
+					notice + ": " + (notice.getParser()==res.getParser()));
+		}
+
+		// NOTE: We must currently remove all notices for the parser.  Parser
+		// implementors are required to parse the entire document each parsing
+		// request, as RSTA is not yet sophisticated enough to determine the
+		// minimum range of text to parse (and ParserNotices' locations aren't
+		// updated when the Document is mutated, which would be a requirement
+		// for this as well).
+		// return same_parser && (in_reparsed_range || in_deleted_end_of_doc)
+		return notice.getParser()==res.getParser();
+
+	}
+
+
+	/**
+	 * Stops parsing the document.
+	 *
+	 * @see #restartParsing()
+	 */
+	public void stopParsing() {
+		timer.stop();
+		running = false;
+	}
+
+
+	/**
+	 * Mapping of a parser notice to its highlight in the editor.
+	 */
+	private static class NoticeHighlightPair {
+
+		private ParserNotice notice;
+		private HighlightInfo highlight;
+
+		NoticeHighlightPair(ParserNotice notice, HighlightInfo highlight) {
+			this.notice = notice;
+			this.highlight = highlight;
+		}
+
+	}
+
+
+	static {
+		boolean debugParsing = false;
+		try {
+			debugParsing = Boolean.getBoolean(PROPERTY_DEBUG_PARSING);
+		} catch (AccessControlException ace) {
+			// Likely an applet's security manager.
+			debugParsing = false; // FindBugs
+		}
+		DEBUG_PARSING = debugParsing;
+	}
+
+
+}