jsbeautifier.java

java写的多功能文件编辑器

/*
 * Copyright (c) 1997, 1998 Tal Davidson. All rights reserved.
 *
 * JSBeautifier 1.1.1
 * by Tal Davidson ([e-mail])
 *
 * JSBeautifier 1.1.1 is distributed under the "Artistic License" 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.*;

/**
 * <code> JSBeautifier </code> (formerly called Beautifier) is a filter for automatic
 * indentation of Java source code. Every line of the original source file should be
 * sent one after the other as a String to the beautify(lineString) method, which
 * returns an automatically indented version of the line it recieves, according to
 * the data in the past lines recieved.
 *
 * Every time a JSBeautifier instance is to be reused for a new file, a call must first
 * be made to its init() method.
 *
 * JSBeautifier can be used either as an object in a program or from the command line.
 *
 * When used from the command line, JSBeautifier can be used both as a filter
 * from standard-input to standard-output, i.e.:
 *     [/home/tald]$ java jstyle.JSBeautifier [flags] < sourceFile.java > resultingFile.java
 * or as a filter to specifically named files, i.e:
 *     [/home/tald]$ java jstyle.JSBeautifier [flags] File1.java File2.java File3.java
 * When Giving JSBeautifier the name of a specific source file, output will
 * be created to another file with the same name, BUT with an added suffix of ".js"
 * Thus, a file named "File1.java" will be renamed to "File1.java.js"
 *
 * Flag options:
 *     -t  (for tabs)
 *     -s# (for '#' spaces per indent, i.e.: -s2)
 *     -ib (add extra indentation to brackets)
 *     -fs (flush (i.e. don't add extra indentation to) switch statements - ala Java Code Convention).
 *     -h  (for help message)
 * The current default setup is 4 spaces per indent, 1 space before every comment line
 *
 *
 * Bug Reporting:
 * 1. If anyone corrects a found bug, please send me an example source-file
 *    that creates the bug, and the corrected version of this file, so that
 *    I can post it.
 * 2. Otherwise, please send me an example source-file cerating the bug, and
 *    the bug description, and i will do my best to correct the bug as soon
 *    as possible.
 *
 *
 * Acknowledgments:
 * - Thanks to Jim Watson for addition of the Help option !!!
 *
 *
 * @author	Tal Davidson <a href=mailto:[e-mail]>[e-mail]</a>
 * @version 1.1.1,  October 10th, 1998
 */
public class JSBeautifier
{
  // headers[] - an array of headers that require indentation
  private static String headers[] = { "if", "else", "for", "while", "do", "try",
                                      "catch", "synchronized", "switch", "case", "default", "static" };

  // nonParenHeaders[] - an array of headers that DONT require parenthesies after them
  private static String nonParenHeaders[] = {"else", "do", "try", "static"};

  // preBlockStatements[] - an array of headers that exist within statements immediately preceding blocks
  private static String preBlockStatements[] = {"class", "interface", "throws"};

  // assignmentOperators[] - an array of assignment operators
  private static String assignmentOperators[] = {"<<", ">>", "=", "+=", "-=", "*=", "/=", "%=", "|=", "&=", "return"};

  // nonAssignmentOperators[] - an array of non-assignment operators
  private static String nonAssignmentOperators[] = {"==", "++", "--", "!="};

  // headerStack - a stack of the headers responsible for indentations of the current char
  private Stack headerStack;

  // tempStacks - a stack of Stacks. Each inner stack holds the current header-list in a { } block.
  // The innermost { } block's stack sits at the top of the tempStacks.
  private Stack tempStacks;

  // blockParenDepthStack - stack of the number of parenthesies that are open when new NESTED BLOCKS are created.
  private Stack blockParenDepthStack;

  // blockStatementStack - stack of the states of 'isInStatement' when new NESTED BLOCKS are created.
  private Stack blockStatementStack;

  // parenStatementStack - stack of the states of 'isInStatement' when new NESTED PARENTHESIES are created.
  private Stack parenStatementStack;

  // inStatementIndentStack - stack of LOCATIONS of in-statement indents
  private Stack inStatementIndentStack;

  // inStatementIndentStackSizeStack - stack of SIZES of inStatementIndentStack stacks
  private Stack inStatementIndentStackSizeStack;

  // parenIndentStack - stack of LOCATIONS of '(' or '[' chars
  private Stack parenIndentStack;

  // bracketBlockStateStack - stack of types of nested '{' brackets.
  // Each element of the stack is either True (=the beginner of a block), or False (=the beginner of a
  // static array).
  private Stack bracketBlockStateStack;

  // isSpecialChar - true if a there exists a '\' preceding the current chararacter.
  //   i.e. \n, \t, \\, ...
  private boolean isSpecialChar;

  // isInQuote - true when the current character is part of a quote (i.e. 'g' or "ffff")
  private boolean isInQuote;

  // isInComment - true when current character is part of a /* */ comment
  private boolean isInComment;

  // isInCase - true if in middle of a case statement (inside a switch);
  private boolean isInCase;

  // isInQuestion - true if in the middle of a '? :' statement
  private boolean isInQuestion;

  // isInStatement - true when current character is a part of an ongoing statement
  private boolean isInStatement;

  // isInClassHeader - true if inside a 'class' statement
  private boolean isInClassHeader;

  // isInClassHeaderTab - true if a special tab has been activated for the 'class statement'
  private boolean isInClassHeaderTab;

  // switchIndent - true if switch blocks should have an additional internal indent.
  private boolean switchIndent;

  // bracketIndent - true if brackets should have an added indent.
  private boolean bracketIndent;

  // quoteChar - the quote delimeter of a quote (' or ")
  private char quoteChar;

  // commmentIndent - the number of spaces to indent when in a comment
  private int commentIndent = 1;

  // parenDepth - the depth of parenthesies around the current character
  private int parenDepth;

  // indentString - the String to be used for every indentation
  // - either a "\t" or a String of n spaces.
  private String indentString;

  // indentLength - the length of one indent unit.
  private int indentLength;

  // blockTabCount - stores number of tabs to add to begining of line
  // due to statements with INNER blocks inside open parenthesies.
  private int blockTabCount;

  private int statementTabCount;

  private int leadingWhiteSpaces;

  private int maxInStatementIndent;

  private char prevNonSpaceCh;

  private char currentNonSpaceCh;

  private String currentHeader;

  private boolean isInHeader;

  private String immediatelyPreviousAssignmentOp;



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

    // manage flags
    for (int i=0; i<args.length; i++)
    {
      String arg = args[i];
      if ("-t".equals(arg))
        beautifier.setTabIndentation();
      else if (arg.startsWith("-s"))
      {
        int spaceNum = 4;
        try {
          spaceNum = Integer.valueOf(arg.substring(2)).intValue();
        } catch (NumberFormatException e) {};
        beautifier.setSpaceIndentation(spaceNum);
      }
      else if (arg.startsWith("-m"))
      {
        int maxIndent = 4;
        try {
          maxIndent = Integer.valueOf(arg.substring(2)).intValue();
        } catch (NumberFormatException e) {};
        beautifier.setMaxInStatementIndetation(maxIndent);
      }
      else if ("-ib".equals(arg))
        beautifier.setBracketIndent(true);
      else if ("-fs".equals(arg))
        beautifier.setSwitchIndent(false);
      else if (arg.startsWith("-") && !isHelpShown)
      {
        isHelpShown = true;

        System.err.println("");
        System.err.println("JSBeautifier 1.1.0   (created by Tal Davidson, [e-mail])");
        System.err.println("");
        System.err.println("Usage  : java jstyle.JSBeautifier [options] < Original.java > Beautified.java");
        System.err.println("         java jstyle.JSBeautifier [options] Foo.java Bar.java  [...]");
        System.err.println("");
        System.err.println("When given a specific file, JSBeautifier 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: -t   Indent using tab characters");
        System.err.println("         -s#  Indent using # spaces per indent (i.e. -s4)");
        System.err.println("         -m#  Indent a maximal # spaces in a continuous statement,");
        System.err.println("              relatively to the previous line(i.e. -m40)");
        System.err.println("         -ib  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.exit(0);
      }
      else // file-name
        fileNameVector.addElement(arg);

    }

    if (fileNameVector.isEmpty())
    {
      inReader = new BufferedReader(new InputStreamReader(System.in));
      outWriter = new PrintWriter(System.out);
      try {
        beautifier.beautifyReader(inReader, outWriter);
      }
      catch (IOException e) {
        System.err.println("Error: " + e);
      }
      outWriter.close();
    }
    else
    {
      for (int i=0; i<fileNameVector.size(); i++)
      {
        beautifier.init();
        try {
          String fileName = (String) fileNameVector.elementAt(i);
          inReader = new BufferedReader(new FileReader(fileName));
          outWriter = new PrintWriter(new FileWriter(fileName+".js"), true);

          beautifier.beautifyReader(inReader, outWriter);
        }
        catch (IOException e) {
          System.err.println("Error: " + e);
        }

        outWriter.close();
        try {
          inReader.close();
        }
        catch (IOException e) {
          System.err.println("Error: " + e);
        }

      }
    }
  }

  /**
   * beautify input from inreader 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 beautifyReader(BufferedReader inReader, PrintWriter outWriter) throws IOException
  {
    String line = null;

    // beautify source code lines
    try {
      while (true)
      {
        line = inReader.readLine();
        if (line == null)
          break;
        outWriter.println(beautify(line));
      }

    } catch (IOException e) {}
  }

  /**
   * JSBeautifier's constructor.
   */
  public JSBeautifier()
  {
    init();
    setSpaceIndentation(4); // the default indentation of a JSBeautifier object is of 4 spaces per indent
    setMaxInStatementIndetation(40);
    setBracketIndent(false);
    setSwitchIndent(true);
  }

  /**
   * initiate the JSBeautifier.
   *
   * init() should be called every time a JSBeautifier object is to start