syntaxfilters.java

具有不同语法高亮的编辑器实例

/*
 * 03/08/2004
 *
 * SyntaxFilters.java - Manages a list of wildcard file filters and what
 *                      syntax highlighting styles they map to.
 */
package org.fife.rtext;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import javax.swing.JOptionPane;

import org.fife.ui.rsyntaxtextarea.SyntaxConstants;

/**
 * Manages a list of wildcard file filters and what syntax highlighting
 * styles they map to.
 *
 * @author Robert Futrell
 * @version 0.1
 */
public class SyntaxFilters
    implements SyntaxConstants {

  /**
   * One filter set for every file type except plain text.
   */
  private ArrayList[] filters;

  /**
   * Default extensions RText matches to syntax styles.
   */
  private static final String[][] DEFAULT_FILTERS = {
      /* X86 asm */ {
      "*.asm"}
      ,
      /* C */{
      "*.c"}
      ,
      /* C++ */{
      "*.cpp", "*.cxx", "*.h"}
      ,
      /* C# */{
      "*.cs"}
      ,
      /* CSS */{
      "*.css"}
      ,
      /* Fortran */{
      "*.f", "*.for", "*.fort", "*.f77", "*.f90"}
      ,
      /* HTML */{
      "*.htm", "*.html"}
      ,
      /* Java */{
      "*.java"}
      ,
      /* JavaScript */{
      "*.js"}
      ,
      /* Perl */{
      "*.perl", "*.pl", "*.pm"}
      ,
      /* Properties files */{
      "*.properties"}
      ,
      /* Python */{
      "*.py"}
      ,
      /* SAS */{
      "*.sas"}
      ,
      /* SQL */{
      "*.sql"}
      ,
      /* UNIX shell */{
      "*.sh", "*.?sh"}
      ,
      /* Win batch */{
      "*.bat", "*.cmd"}
      ,
      /* XML */{
      "*.xml", "*.macro", "*.manifest"}
      ,
  };

      /*****************************************************************************/

  /**
   * Creates a new <code>SyntaxFilters</code> with default values for
   * all filters.
   */
  public SyntaxFilters() {
    this(null);
  }

      /*****************************************************************************/

  /**
   * Creates a new <code>SyntaxFilters</code> from the given string.
   *
   * @param filterString Must be a <code>String</code> generated from
   *                     <code>SyntaxFilter.toString()</code>.  If its
   *                     format is invalid, then default filter strings are
   *                     used for all syntax styles.
   */
  public SyntaxFilters(String filterString) {

    // One filter set for every file type except plain text.
    filters = new ArrayList[MAX_SYNTAX_STYLE_NUMBER];

    for (int i = 0; i < MAX_SYNTAX_STYLE_NUMBER; i++) {
      filters[i] = new ArrayList();
    }
    restoreDefaultFileFilters();

    int i = 1; // Start at 1 to skip 0==NO_SYNTAX_STYLE.
    if (filterString != null) {
      int oldCommaPos = 0;
      int commaPos = filterString.indexOf(',', 0);
      while (commaPos != -1) {
        String token = filterString.substring(oldCommaPos, commaPos);
        setFiltersForSyntaxStyle(i++, token);
        oldCommaPos = commaPos + 1;
        commaPos = filterString.indexOf(',', oldCommaPos);
      }
      // Get the last one (with no trailing comma).
      setFiltersForSyntaxStyle(i, filterString.substring(oldCommaPos));
    }

    // Use the defaults for all file filters if the file filter string
    // was "too short" to cover all syntax styles.  This is because we may
    // have added a new syntax style somewhere in the middle, and this
    // would mess up our filter->style mapping.
    if (i != MAX_SYNTAX_STYLE_NUMBER) {
      restoreDefaultFileFilters();
    }

  }

      /*****************************************************************************/

  /**
   * Adds a file filter for a given syntax style.
   *
   * @param syntaxStyle The syntax style to add a file filter to.  If this
   *                    style is less than 1 or greater than
   *                    <code>MAX_SYNTAX_STYLE_NUMBER</code>, this method
   *                    will do nothing.
   * @param filter The filter to add.  If <code>null</code>, nothing will
   *               be done.
   */
  public void addFileFilter(final int syntaxStyle, final String filter) {

    if (syntaxStyle < 1 || syntaxStyle > MAX_SYNTAX_STYLE_NUMBER ||
        filter == null) {
      return;
    }

    // -1 because we don't have filters for NO_SYNTAX_STYLE.
    filters[syntaxStyle - 1].add(filter);

  }

      /*****************************************************************************/

  /**
   * Returns a list of all wildcard file filters associated with this
   * syntax type, separated by spaces.  For example, if the C++ syntax
   * style has filters <code>*.cpp</code> and <code>*.h</code> associated
   * with it, then <code>getFilterString(CPLUSPLUS_SYNTAX_STYLE)</code>
   * would return <code>"*.cpp *.h"</code>.
   *
   * @param syntaxStyle The syntax style for which to retrieve the
   *                    string.  If it is less than 1 or greater than
   *                    <code>SyntaxConstants.MAX_STYLE_NUMBER</code>,
   *                    <code>null</code> is returned.
   */
  public String getFilterString(int syntaxStyle) {

    if (syntaxStyle < 1 ||
        syntaxStyle > SyntaxConstants.MAX_SYNTAX_STYLE_NUMBER) {
      return null;
    }

    // -1 because we don't have filters for NO_SYNTAX_STYLE.
    Iterator iterator = filters[syntaxStyle - 1].iterator();

    String filterString = "";
    while (iterator.hasNext()) {
      filterString += (String) iterator.next() + " ";

    }
    return filterString;

  }

      /*****************************************************************************/

  /**
   * Returns the type of syntax highlighting to use for the given text
   * file based on its extension and the current filters.
   *
   * @param fileName The file to syntax highlight.
   * @return The syntax highlighting scheme to use, for example,
   *         <code>JAVA_SYNTAX_STYLE</code> or
   *         <code>CPLUSPLUS_SYNTAX_STYLE</code>.
   * @see org.fife.ui.rsyntaxtextarea.RSyntaxTextArea
   * @see org.fife.ui.rsyntaxtextarea.SyntaxConstants
   */
  public int getSyntaxStyleForFile(final String fileName) {

    if (fileName == null) {
      return NO_SYNTAX_STYLE;
    }

    Iterator iterator;
    String regEx;

    final String fileNameLowerCase = fileName.toLowerCase();

    for (int i = 0; i < MAX_SYNTAX_STYLE_NUMBER; i++) {
      iterator = filters[i].iterator();
      while (iterator.hasNext()) {
        regEx = RTextUtilities.getRegularExpressionForFileFilter(
            (String) iterator.next(), true);
        if (regEx != null && fileNameLowerCase.matches(regEx)) {

          // +1 because we have no file filters for NO_SYNTAX_STYLE.
          return i + 1;
        }
      }
    }

    return NO_SYNTAX_STYLE;

  }

      /*****************************************************************************/

  /**
   * Returns <code>true</code> if and only if the file filter string passed
   * in is "valid".  Currently valid file filter strings contain only the
   * following characters: A-Z, a-z, 0-9, '*', '?', '.', '-', '_', ' ', '$'.
   *
   * @param fileFilterString The file filter string to test.
   * @return <code>true</code> if the file filter string is valid, false
   *         otherwise.
   */
  public static boolean isValidFileFilterString(String fileFilterString) {
    int length = fileFilterString.length();
    for (int i = 0; i < length; i++) {
      char c = fileFilterString.charAt(i);
      switch (c) {
        case '*':
        case '?':
        case '.':
        case '-':
        case '_':
        case '$':
        case ' ':
          continue;
        default:
          if (!Character.isLetterOrDigit(c)) {
            return false;
          }
      }
    }
    return true;
  }

      /*****************************************************************************/

  /**
   * Sets default values for syntax filters.
   */
  public void restoreDefaultFileFilters() {

    // NOTE:  We loop through this way instead of hard-coding
    // filter-to-syntax-style values because if we ever add new
    // syntax styles in the future, this method will still be sound
    // (once the new styles are added in, of course).
    for (int i = 0; i < MAX_SYNTAX_STYLE_NUMBER; i++) {
      filters[i].clear();
      String[] defaults = DEFAULT_FILTERS[i];
      for (int j = 0; j < defaults.length; j++) {
        filters[i].add(defaults[j]);
      }
    }

  }

      /*****************************************************************************/

  /**
   * Sets all file filters for a given syntax style.
   *
   * @param syntaxStyle The syntax style for which to set the file filters.
   *                    If this parameter is less than 1 or greater than
   *                    <code>MAX_SYNTAX_STYLE_NUMBER</code> then nothing
   *                    happens.
   * @param filterString A string representing the file filters separated
   *                     by spaces.  If <code>null</code>, nothing happens.
   */
  public void setFiltersForSyntaxStyle(int syntaxStyle, String filterString) {

    if (syntaxStyle < 1 ||
        syntaxStyle > SyntaxConstants.MAX_SYNTAX_STYLE_NUMBER ||
        filterString == null) {
      return;
    }

    //StringTokenizer st = new StringTokenizer(filterString);
    ArrayList tempList = filters[syntaxStyle - 1]; // -1 since we have no NO_SYNTAX_STYLE filters.

    tempList.clear();
    int oldSpacePos = 0;
    int spacePos = filterString.indexOf(' ', 0);
    while (spacePos != -1) {
      String token = filterString.substring(oldSpacePos, spacePos);
      if (!token.equals("")) {
        tempList.add(token);
      }
      oldSpacePos = spacePos + 1;
      spacePos = filterString.indexOf(' ', oldSpacePos);
    }
    if (oldSpacePos < filterString.length() - 1) {
      tempList.add(filterString.substring(oldSpacePos));

    }
    tempList = null;

  }

      /*****************************************************************************/

  /**
   * Returns this object as a string.
   *
   * @return A string representing this <code>SyntaxFilters</code>.
   */
  public String toString() {
    String retVal = "";
    for (int i = 0; i < MAX_SYNTAX_STYLE_NUMBER; i++) {
      retVal += getFilterString(i + 1) + ",";
      // Get rid of the last comma.
    }
    retVal = retVal.substring(0, retVal.length() - 1);
    return retVal;
  }

      /*****************************************************************************/

}