/* * @(#)RTFParser.java	1.11 03/12/19 * * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */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 = (boolean[])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();  }}