Back to index...

	/*
	* Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package javax.swing.text.rtf;

	import java.io.*;
	import java.lang.*;

	/**
	* <b>RTFParser</b> is a subclass of <b>AbstractFilter</b> which understands basic RTF syntax
	* and passes a stream of control words, text, and begin/end group
	* indications to its subclass.
	*
	* Normally programmers will only use <b>RTFFilter</b>, a subclass of this class that knows what to
	* do with the tokens this class parses.
	*
	* @see AbstractFilter
	* @see RTFFilter
	*/
	abstract class RTFParser extends AbstractFilter
	{
	/** The current RTF group nesting level. */
	public int level;

	private int state;
	private StringBuffer currentCharacters;
	private String pendingKeyword; // where keywords go while we
	// read their parameters
	private int pendingCharacter; // for the \'xx construct

	private long binaryBytesLeft; // in a \bin blob?
	ByteArrayOutputStream binaryBuf;
	private boolean[] savedSpecials;

	/** A stream to which to write warnings and debugging information
	* while parsing. This is set to <code>System.out</code> to log
	* any anomalous information to stdout. */
	protected PrintStream warnings;

	// value for the 'state' variable
	private final int S_text = 0; // reading random text
	private final int S_backslashed = 1; // read a backslash, waiting for next
	private final int S_token = 2; // reading a multicharacter token
	private final int S_parameter = 3; // reading a token's parameter

	private final int S_aftertick = 4; // after reading \'
	private final int S_aftertickc = 5; // after reading \'x

	private final int S_inblob = 6; // in a \bin blob

	/** Implemented by subclasses to interpret a parameter-less RTF keyword.
	* The keyword is passed without the leading '/' or any delimiting
	* whitespace. */
	public abstract boolean handleKeyword(String keyword);
	/** Implemented by subclasses to interpret a keyword with a parameter.
	* @param keyword The keyword, as with <code>handleKeyword(String)</code>.
	* @param parameter The parameter following the keyword. */
	public abstract boolean handleKeyword(String keyword, int parameter);
	/** Implemented by subclasses to interpret text from the RTF stream. */
	public abstract void handleText(String text);
	public void handleText(char ch)
	{ handleText(String.valueOf(ch)); }
	/** Implemented by subclasses to handle the contents of the \bin keyword. */
	public abstract void handleBinaryBlob(byte[] data);
	/** Implemented by subclasses to react to an increase
	* in the nesting level. */
	public abstract void begingroup();
	/** Implemented by subclasses to react to the end of a group. */
	public abstract void endgroup();

	// table of non-text characters in rtf
	static final boolean rtfSpecialsTable[];
	static {
	rtfSpecialsTable = noSpecialsTable.clone();
	rtfSpecialsTable['\n'] = true;
	rtfSpecialsTable['\r'] = true;
	rtfSpecialsTable['{'] = true;
	rtfSpecialsTable['}'] = true;
	rtfSpecialsTable['\\'] = true;
	}

	public RTFParser()
	{
	currentCharacters = new StringBuffer();
	state = S_text;
	pendingKeyword = null;
	level = 0;
	//warnings = System.out;

	specialsTable = rtfSpecialsTable;
	}

	// TODO: Handle wrapup at end of file correctly.

	public void writeSpecial(int b)
	throws IOException
	{
	write((char)b);
	}

	protected void warning(String s) {
	if (warnings != null) {
	warnings.println(s);
	}
	}

	public void write(String s)
	throws IOException
	{
	if (state != S_text) {
	int index = 0;
	int length = s.length();
	while(index < length && state != S_text) {
	write(s.charAt(index));
	index ++;
	}

	if(index >= length)
	return;

	s = s.substring(index);
	}

	if (currentCharacters.length() > 0)
	currentCharacters.append(s);
	else
	handleText(s);
	}

	public void write(char ch)
	throws IOException
	{
	boolean ok;

	switch (state)
	{
	case S_text:
	if (ch == '\n' \|\| ch == '\r') {
	break; // unadorned newlines are ignored
	} else if (ch == '{') {
	if (currentCharacters.length() > 0) {
	handleText(currentCharacters.toString());
	currentCharacters = new StringBuffer();
	}
	level ++;
	begingroup();
	} else if(ch == '}') {
	if (currentCharacters.length() > 0) {
	handleText(currentCharacters.toString());
	currentCharacters = new StringBuffer();
	}
	if (level == 0)
	throw new IOException("Too many close-groups in RTF text");
	endgroup();
	level --;
	} else if(ch == '\\') {
	if (currentCharacters.length() > 0) {
	handleText(currentCharacters.toString());
	currentCharacters = new StringBuffer();
	}
	state = S_backslashed;
	} else {
	currentCharacters.append(ch);
	}
	break;
	case S_backslashed:
	if (ch == '\'') {
	state = S_aftertick;
	break;
	}
	if (!Character.isLetter(ch)) {
	char newstring[] = new char[1];
	newstring[0] = ch;
	if (!handleKeyword(new String(newstring))) {
	warning("Unknown keyword: " + newstring + " (" + (byte)ch + ")");
	}
	state = S_text;
	pendingKeyword = null;
	/* currentCharacters is already an empty stringBuffer */
	break;
	}

	state = S_token;
	/* FALL THROUGH */
	case S_token:
	if (Character.isLetter(ch)) {
	currentCharacters.append(ch);
	} else {
	pendingKeyword = currentCharacters.toString();
	currentCharacters = new StringBuffer();

	// Parameter following?
	if (Character.isDigit(ch) \|\| (ch == '-')) {
	state = S_parameter;
	currentCharacters.append(ch);
	} else {
	ok = handleKeyword(pendingKeyword);
	if (!ok)
	warning("Unknown keyword: " + pendingKeyword);
	pendingKeyword = null;
	state = S_text;

	// Non-space delimiters get included in the text
	if (!Character.isWhitespace(ch))
	write(ch);
	}
	}
	break;
	case S_parameter:
	if (Character.isDigit(ch)) {
	currentCharacters.append(ch);
	} else {
	/* TODO: Test correct behavior of \bin keyword */
	if (pendingKeyword.equals("bin")) { /* magic layer-breaking kwd */
	long parameter = Long.parseLong(currentCharacters.toString());
	pendingKeyword = null;
	state = S_inblob;
	binaryBytesLeft = parameter;
	if (binaryBytesLeft > Integer.MAX_VALUE)
	binaryBuf = new ByteArrayOutputStream(Integer.MAX_VALUE);
	else
	binaryBuf = new ByteArrayOutputStream((int)binaryBytesLeft);
	savedSpecials = specialsTable;
	specialsTable = allSpecialsTable;
	break;
	}

	int parameter = Integer.parseInt(currentCharacters.toString());
	ok = handleKeyword(pendingKeyword, parameter);
	if (!ok)
	warning("Unknown keyword: " + pendingKeyword +
	" (param " + currentCharacters + ")");
	pendingKeyword = null;
	currentCharacters = new StringBuffer();
	state = S_text;

	// Delimiters here are interpreted as text too
	if (!Character.isWhitespace(ch))
	write(ch);
	}
	break;
	case S_aftertick:
	if (Character.digit(ch, 16) == -1)
	state = S_text;
	else {
	pendingCharacter = Character.digit(ch, 16);
	state = S_aftertickc;
	}
	break;
	case S_aftertickc:
	state = S_text;
	if (Character.digit(ch, 16) != -1)
	{
	pendingCharacter = pendingCharacter * 16 + Character.digit(ch, 16);
	ch = translationTable[pendingCharacter];
	if (ch != 0)
	handleText(ch);
	}
	break;
	case S_inblob:
	binaryBuf.write(ch);
	binaryBytesLeft --;
	if (binaryBytesLeft == 0) {
	state = S_text;
	specialsTable = savedSpecials;
	savedSpecials = null;
	handleBinaryBlob(binaryBuf.toByteArray());
	binaryBuf = null;
	}
	}
	}

	/** Flushes any buffered but not yet written characters.
	* Subclasses which override this method should call this
	* method <em>before</em> flushing
	* any of their own buffers. */
	public void flush()
	throws IOException
	{
	super.flush();

	if (state == S_text && currentCharacters.length() > 0) {
	handleText(currentCharacters.toString());
	currentCharacters = new StringBuffer();
	}
	}

	/** Closes the parser. Currently, this simply does a <code>flush()</code>,
	* followed by some minimal consistency checks. */
	public void close()
	throws IOException
	{
	flush();

	if (state != S_text \|\| level > 0) {
	warning("Truncated RTF file.");

	/* TODO: any sane way to handle termination in a non-S_text state? */
	/* probably not */

	/* this will cause subclasses to behave more reasonably
	some of the time */
	while (level > 0) {
	endgroup();
	level --;
	}
	}

	super.close();
	}

	}

Back to index...