jsformatter.java

java写的多功能文件编辑器

/*
 * Copyright (c) 1998 Tal Davidson. All rights reserved.
 *
 * JSFormatter 0.4.0
 * by Tal Davidson ([e-mail])
 *
 * JSFormatter 0.4.0 is distributed under the "Artistic Licence" detailed below:
 *
 *
 *                           The ``Artistic License''
 *
 * Preamble
 * The intent of this document is to state the conditions under which a Package may
 * be copied, such that the Copyright Holder maintains some semblance of artistic
 * control over the development of the package, while giving the users of the
 * package the right to use and distribute the Package in a more-or-less customary
 * fashion, plus the right to make reasonable modifications.
 *
 * Definitions
 *     ``Package'' refers to the collection of files distributed by the Copyright
 *     Holder, and derivatives of that collection of files created through textual
 *     modification.
 *     ``Standard Version'' refers to such a Package if it has not been modified,
 *     or has been modified in accordance with the wishes of the Copyright Holder
 *     as specified below.
 *     ``Copyright Holder'' is whoever is named in the copyright or copyrights for
 *     the package.
 *     ``You'' is you, if you're thinking about copying or distributing this
 *     Package.
 *     ``Reasonable copying fee'' is whatever you can justify on the basis of media
 *     cost, duplication charges, time of people involved, and so on. (You will not
 *     be required to justify it to the Copyright Holder, but only to the computing
 *     community at large as a market that must bear the fee.)
 *     ``Freely Available'' means that no fee is charged for the item itself,
 *     though there may be fees involved in handling the item. It also means that
 *     recipients of the item may redistribute it under the same conditions they
 *     received it.
 *
 *     1. You may make and give away verbatim copies of the source form of the
 *        Standard Version of this Package without restriction, provided that you
 *        duplicate all of the original copyright notices and associated disclaimers.
 *     2. You may apply bug fixes, portability fixes and other modifications derived
 *        from the Public Domain or from the Copyright Holder. A Package modified in
 *        such a way shall still be considered the Standard Version.
 *     3. You may otherwise modify your copy of this Package in any way, provided that
 *        you insert a prominent notice in each changed file stating how and when you
 *        changed that file, and provided that you do at least ONE of the following:
 *         a. place your modifications in the Public Domain or otherwise make them
 *            Freely Available, such as by posting said modifications to Usenet or an
 *            equivalent medium, or placing the modifications on a major archive site
 *            such as uunet.uu.net, or by allowing the Copyright Holder to include
 *            your modifications in the Standard Version of the Package.
 *         b. use the modified Package only within your corporation or organization.
 *         c. rename any non-standard executables so the names do not conflict with
 *            standard executables, which must also be provided, and provide a
 *            separate manual page for each non-standard executable that clearly
 *            documents how it differs from the Standard Version.
 *         d. make other distribution arrangements with the Copyright Holder.
 *     4. You may distribute the programs of this Package in object code or executable
 *        form, provided that you do at least ONE of the following:
 *         a. distribute a Standard Version of the executables and library files,
 *            together with instructions (in the manual page or equivalent) on where
 *            to get the Standard Version.
 *         b. accompany the distribution with the machine-readable source of the
 *            Package with your modifications.
 *         c. give non-standard executables non-standard names, and clearly document
 *            the differences in manual pages (or equivalent), together with
 *            instructions on where to get the Standard Version.
 *         d. make other distribution arrangements with the Copyright Holder.
 *     5. You may charge a reasonable copying fee for any distribution of this
 *        Package. You may charge any fee you choose for support of this Package. You
 *        may not charge a fee for this Package itself. However, you may distribute
 *        this Package in aggregate with other (possibly commercial) programs as part
 *        of a larger (possibly commercial) software distribution provided that you do
 *        not advertise this Package as a product of your own. You may embed this
 *        Package's interpreter within an executable of yours (by linking); this shall
 *        be construed as a mere form of aggregation, provided that the complete
 *        Standard Version of the interpreter is so embedded.
 *     6. The scripts and library files supplied as input to or produced as output
 *        from the programs of this Package do not automatically fall under the
 *        copyright of this Package, but belong to whomever generated them, and may be
 *        sold commercially, and may be aggregated with this Package. If such scripts
 *        or library files are aggregated with this Package via the so-called "undump"
 *        or "unexec" methods of producing a binary executable image, then
 *        distribution of such an image shall neither be construed as a distribution
 *        of this Package nor shall it fall under the restrictions of Paragraphs 3 and
 *        4, provided that you do not represent such an executable image as a Standard
 *        Version of this Package.
 *     7. C subroutines (or comparably compiled subroutines in other languages)
 *        supplied by you and linked into this Package in order to emulate subroutines
 *        and variables of the language defined by this Package shall not be
 *        considered part of this Package, but are the equivalent of input as in
 *        Paragraph 6, provided these subroutines do not change the language in any
 *        way that would cause it to fail the regression tests for the language.
 *     8. Aggregation of this Package with a commercial distribution is always
 *        permitted provided that the use of this Package is embedded; that is, when
 *        no overt attempt is made to make this Package's interfaces visible to the
 *        end user of the commercial distribution. Such use shall not be construed as
 *        a distribution of this Package.
 *     9. The name of the Copyright Holder may not be used to endorse or promote
 *        products derived from this software without specific prior written
 *        permission.
 *        THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 *        WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 *        MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * The End
 */

import java.util.*;
import java.io.*;

public class JSFormatter {
  // headers[] - an array of headers that require indentation
  private static String headers[] = {"if", "else", "for", "while", "do",
  "try", "catch", "synchronized", "switch", "static"};

  // parenHeaders[] - an array of the headers that require parenthesies after them, i.e. while (...)
  private static String parenHeaders[] = {"if", "for", "while", "catch",
  "synchronized", "switch"};

  private static String nonParenHeaders[] = {"else", "do", "try", "static"};

  private static String statementHeaders[] = {"class", "interface", "throws"};

  private static String longOperators[] = {"==", "!=", ">=", "<=", "+=",
  "-=", "*=", "/=", "%=", "^=", "|=", "&=", "++", "--", "&&", "||", ".*" };

  private static Hashtable closingHeaders;
  static {
    closingHeaders = new Hashtable();
    closingHeaders.put("if", "else");
    closingHeaders.put("do", "while");
    closingHeaders.put("try", "catch");
  }

  public JSBeautifier beautifier;
  private JSLineBreaker lineBreaker;
  private StringBuffer outBuffer; // current parsed-line buffer
  private String tempLine = ""; // parts of previous line that haven't been parsed yet
  private Stack openingStack;
  private Stack parenDepthsStack;

  private Stack bracketBlockStateStack;
  private char quoteChar;
  private int parenDepth;
  private int leadingWhiteSpaces;
  private String currentHeader;
  private boolean isInHeader;

  private boolean isSpecialChar; // true if a char of type '\X' (i.e. '\n'...)
  private boolean isInQuote; // true if in quote
  private boolean isInComment; // true if in /**/ comment
  private boolean isBlockNeeded; // ---not currently used.
  private boolean isSpecialBlock; // ---not currently used.
  private boolean isCloseSpecialBlock; // ---not currently used.
  private boolean isParenNeeded; // true if a parenthesis statement is expected (i.e. right after a 'while' header...)
  private boolean isNewLineNeeded; // true if current formatted line has reached its end.
  private boolean checkBlockOpen; // hint for  checking if a '{' has been reached
  private boolean checkBlockClose; // hint for  checking if a '}' has been reached
  private boolean checkIf;
  private boolean checkClosingHeader;
  private boolean foundOrigLineBreak;
  private boolean isInQuestion;
  private boolean isSummarized;
  private boolean isInBracketOpen;
  private boolean isInBracketClose;
  private boolean isInClassStatement;
  private boolean bracketBreak = false;

  private char prevNonSpaceCh;
  private char currentNonSpaceCh;


  public static void main(String args[]) {
    JSFormatter formatter = new JSFormatter();
    Vector fileNameVector = new Vector();
    BufferedReader inReader = null;
    PrintWriter outWriter = null;
    boolean isHelpShown = false;


    for (int i = 0; i < args.length; i++) {
      String arg = args[i];
      if (arg.equals("-b"))
        formatter.setBracketBreak(true);
      else if ("-ib".equals(arg)) {
        formatter.setBracketBreak(true);
        formatter.setBracketIndent(true);
      } else if ("-fs".equals(arg))
        formatter.setSwitchIndent(false);
      else if (arg.startsWith("-ll")) {
        int length = 70;
        try {
          length = Integer.valueOf(arg.substring(3)).intValue();
        } catch (NumberFormatException e) {};
        formatter.setPreferredLineLength(length);
      } else if (arg.startsWith("-ld")) {
        int dev = 5;
        try {
          dev = Integer.valueOf(arg.substring(3)).intValue();
        } catch (NumberFormatException e) {};
        formatter.setLineLengthDeviation(dev);
      } else if (arg.equals("-nn")) {
        formatter.setNestedConnection(false);
      } else if (arg.startsWith("-") && !isHelpShown) {
        isHelpShown = true;

        System.err.println("");
        System.err.println("Usage  : java jstyle.JSFormatter [options] < Original.java > Formatted.java");
        System.err.println("         java jstyle.JSFormatter [options] Foo.java Bar.java  [...]");
        System.err.println("");
        System.err.println("When given a specific file, JSFormatter will create an output file with a");
        System.err.println("suffix of \".js\" added to the original filename, i.e: Foo.java --> Foo.java.js");
        System.err.println("");
        System.err.println("Options: -ll#  Set preferred line length to #");
        System.err.println("         -ld#  Set preferred upper line length deviation to #");
        System.err.println("         -b    Break lines BEFORE '{' brackets (ala C++ style)");
        System.err.println("         -ib   Same as '-b', but add extra indentation to brackets");
        System.err.println("         -fs   flush (i.e. don't indent) 'switch' blocks");
        System.err.println("         -h    Print this help message");
        System.err.println();
        System.exit(0);
      } else
        fileNameVector.addElement(arg);
    }

    if (fileNameVector.isEmpty()) {
      inReader = new BufferedReader(new InputStreamReader(System.in));
      outWriter = new PrintWriter(System.out);

      try {
        formatter.format(inReader, outWriter);
      } catch (IOException e) {
        e.printStackTrace();
      }

      try {
        inReader.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
      outWriter.close();
    } else {
      for (int i = 0; i < fileNameVector.size(); i++) {
        try {
          String fileName = (String) fileNameVector.elementAt(i);
          inReader = new BufferedReader(new FileReader(fileName));
          outWriter =
                  new PrintWriter(new FileWriter(fileName + ".js"), true);

          formatter.format(inReader, outWriter);
        } catch (IOException e) {
          e.printStackTrace();
        }

        outWriter.close();
        try {
          inReader.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }

  }

  /**
   * Constructor for JSFormatter
   */
  public JSFormatter() {
    beautifier = new JSBeautifier();
    lineBreaker = new JSLineBreaker();
    init();
  }

  /**
    * Initialize the formatter so that it is ready for the formation
    * of a new file of source code.
    */
  public void init() {
    beautifier.init();
    lineBreaker.init();

    outBuffer = new StringBuffer();
    openingStack = new Stack();
    parenDepthsStack = new Stack();
    bracketBlockStateStack = new Stack();
    bracketBlockStateStack.push(new Boolean(true));
    tempLine = "";
    parenDepth = 0;
    isSpecialChar = false;
    isInQuote = false;
    isInComment = false;
    isBlockNeeded = false;
    isParenNeeded = false;
    isSpecialBlock = false;
    isCloseSpecialBlock = false;
    isNewLineNeeded = false;
    checkIf = false;
    checkBlockOpen = false;
    checkClosingHeader = false;
    checkBlockClose = false;
    foundOrigLineBreak = false;
    isInQuestion = false;
    isSummarized = false;
    isInBracketOpen = false;
    isInBracketClose = false;
    leadingWhiteSpaces = 0;
    isInHeader = false;
    isInClassStatement = false;

    prevNonSpaceCh = '{';
    currentNonSpaceCh = '{';


  }

  /**
    * Format source code that is read from inReader, and print the
    * formatted result to outWriter.
    *
    * @param      inReader     a BufferedReader from which to input original source code
    * @param      outWriter    a PrintWriter to output beutified source code to
    *
    * @exception  IOException
    */
  public void format(BufferedReader inReader,
          PrintWriter outWriter) throws IOException {
    String line = null;

    init();

    try {
      while (true) {
        while (!hasMoreFormattedLines()) {
          line = inReader.readLine();
          if (line == null)
            throw new NullPointerException();
          formatLine(line);
        }

        while (hasMoreFormattedLines())
          outWriter.println(nextFormattedLine());
      }
    } catch (NullPointerException e) {}

    summarize();

    while (hasMoreFormattedLines())
      outWriter.println(nextFormattedLine());
  }

  /**
    * Check if the formatter has more formatted lines to return.
    *
    * As long as there are more formatted lines to return, the
    * caller should NOT call the method formatLine() with a new
    * line of source code, but rather collect the current available