javapropertiestokenizer.java

Eclipse高级编程3源码(书本源码)

/*******************************************************************************
 * Copyright (c) 2003 Berthold Daum.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     Berthold Daum
 *******************************************************************************/
package com.bdaum.SpellChecker.JavaProperties;

import com.bdaum.SpellChecker.AbstractDocumentWordTokenizer;
import com.bdaum.SpellChecker.SpellCheckConfiguration;

/*********************************************************************
 * This class parses Java.properties files. Optionally key words and
 * comment lines can be checked. We implement a finite state
 * automaton.
 */

public class JavaPropertiesTokenizer
        extends
          AbstractDocumentWordTokenizer {

  // JavaProperties specific
  /** the different states of the automaton * */
  private static final int WHITESPACE = 0;
  private static final int KEY = 1;
  private static final int TEXT = 2;
  private static final int COMMENT = 3;
  private static final int ESCAPE = 4;
  private static final int KEYESCAPE = 5;
  private static final int CONTINUATION = 6;

  /** Current state of the automaton * */
  private int state = WHITESPACE;

  /** Configuration * */
  private boolean checkComments;
  private boolean checkKeys;

  /*
   * Fetches the user options
   * 
   * @see com.bdaum.SpellChecker.AbstractDocumentWordTokenizer#configure()
   */
  protected void configure() {
    super.configure();
    SpellCheckConfiguration config = getCofiguration();
    checkComments = config
            .getBoolean(JavaPropertiesPreferences.CHECKCOMMENTS);
    checkKeys = config
            .getBoolean(JavaPropertiesPreferences.CHECKKEYS);
  }

  protected boolean isWordBreak(
    char ch, boolean notFirst) {
    if (state == KEY && notFirst) {
      return !Character.isLowerCase(ch);
    }
    return !Character.isLetterOrDigit(ch);
  }

  /**
   * Checks the current state against the user options
   * 
   * @see com.bdaum.SpellChecker.AbstractDocumentWordTokenizer
   *      #isToBeChecked()
   */
  protected boolean isToBeChecked() {
    switch (state) {
      case TEXT :
        return true;
      case COMMENT :
        return checkComments;
      case KEY :
        return checkKeys;
      default :
        return false;
    }
  }

  /**
   * Never used.
   * 
   * @see com.bdaum.SpellChecker.AbstractDocumentWordTokenizer
   *      #parseCharacter(char)
   */
  protected void parseCharacter(
    char ch) {}

  /**
   * The automatons state transition table
   * 
   * @see com.bdaum.SpellChecker.AbstractDocumentWordTokenizer
   *      #parseCharacter(char)
   */
  protected char parseAndTranslateCharacter(
    char ch) {
    switch (state) {
      case WHITESPACE :
        if (Character.isWhitespace(ch)) break;
        switch (ch) {
          case '!' :
          case '#' :
            state = COMMENT;
            break;
          default :
            state = KEY;
        }
        break;
      case COMMENT :
        switch (ch) {
          case '\n' :
          case '\r' :
            state = WHITESPACE;
            break;
        }
        break;
      case KEY :
        switch (ch) {
          case ' ' :
          case ':' :
          case '=' :
            state = TEXT;
            break;
          case '.' :
          case '_' :
            return ' ';
          case '\\' :
            state = KEYESCAPE;
            break;
        }
        break;
      case TEXT :
        switch (ch) {
          case '\\' :
            state = ESCAPE;
            break;
          case '&' :
            return 0;
          case '\n' :
          case '\r' :
            state = WHITESPACE;
            break;
        }
        break;
      case KEYESCAPE :
        state = KEY;
        switch (ch) {
          case 'n' :
            return '\n';
          case 'r' :
            return '\r';
          case 't' :
            return '\t';
          case '\\' :
            return '\\';
          case ' ' :
            return ' ';
          case '\'' :
            return '\'';
          case '"' :
            return '"';
        }
        break;
      case ESCAPE :
        state = TEXT;
        switch (ch) {
          case '\n' :
          case '\r' :
            state = CONTINUATION;
            break;
          case 'n' :
            return '\n';
          case 'r' :
            return '\r';
          case 't' :
            return '\t';
          case '\\' :
            return '\\';
          case ' ' :
            return ' ';
          case '\'' :
            return '\'';
          case '"' :
            return '"';
        }
        break;
      case CONTINUATION :
        switch (ch) {
          case '\n' :
          case '\r' :
            state = CONTINUATION;
            break;
          default :
            state = TEXT;
        }
        break;
    }
    return ch;
  }

  /*
   * Remove accelerator character from word
   * 
   * @see com.bdaum.SpellChecker.AbstractDocumentWordTokenizer#deSerialize(java.lang.String)
   */
  public String deSerialize(
    String word) {
    int p = word.indexOf('&');
    if (p >= 0 && p < word.length() - 1) {
      return word.substring(0, p) + word.substring(p + 1);
    }
    return word;
  }
}