示例#1
0
  /** Creates a new NodeWriter object. */
  protected NodeWriter(CompositeFactory factory) {
    this.state = new PrinterState(this);
    this._factory = factory;
    this.lineSeparator = File.separator;
    this.settings = Convention.getInstance();
    this.indentSize =
        AbstractPrinter.settings.getInt(ConventionKeys.INDENT_SIZE, ConventionDefaults.INDENT_SIZE);
    this.insertTrailingEmpty =
        AbstractPrinter.settings.getBoolean(
            ConventionKeys.INSERT_TRAILING_NEWLINE, ConventionDefaults.INSERT_TRAILING_NEWLINE);
    this.continuationIndentSize =
        AbstractPrinter.settings.getInt(
            ConventionKeys.INDENT_SIZE_CONTINUATION, ConventionDefaults.INDENT_SIZE_CONTINUATION);
    this.leftBraceNewline =
        AbstractPrinter.settings.getBoolean(
            ConventionKeys.BRACE_NEWLINE_LEFT, ConventionDefaults.BRACE_NEWLINE_LEFT);
    this.leftBraceIndent =
        AbstractPrinter.settings.getInt(
            ConventionKeys.INDENT_SIZE_BRACE_LEFT, ConventionDefaults.INDENT_SIZE_BRACE_LEFT);
    this.leadingIndentSize =
        AbstractPrinter.settings.getInt(
            ConventionKeys.INDENT_SIZE_LEADING, ConventionDefaults.INDENT_SIZE_LEADING);
    this.useTabs =
        AbstractPrinter.settings.getBoolean(
            ConventionKeys.INDENT_WITH_TABS, ConventionDefaults.INDENT_WITH_TABS);
    this.useLeadingTabs =
        AbstractPrinter.settings.getBoolean(
            ConventionKeys.INDENT_WITH_TABS_ONLY_LEADING,
            ConventionDefaults.INDENT_WITH_TABS_ONLY_LEADING);
    this.footer =
        AbstractPrinter.settings.getBoolean(ConventionKeys.FOOTER, ConventionDefaults.FOOTER);
    _indentChars = new char[150];

    for (int i = 0; i < _indentChars.length; i++) {
      _indentChars[i] = ' ';
    }

    if (this.leadingIndentSize > 0) {
      _leadingIndentSizeString = getString(this.leadingIndentSize);

      if (this.useTabs) {
        _leadingIndentSizeString =
            StringHelper.replace(_leadingIndentSizeString, getString(this.indentSize), TAB);
      }
    }
  }
  /**
   * Creates a new entry.
   *
   * @param location location of the package to add.
   * @param path path to add.
   * @param types the package types.
   * @param verify if <code>true</code> the package root check will be performed.
   * @return if <code>verify == true</code> returns <code>true</code> when the given location could
   *     be verified, <code>false</code> if the given location is no package root; otherwise always
   *     returns <code>true</code>.
   */
  private static boolean createEntryImpl(
      File location, String path, final Set types, boolean verify) {
    // strip extension
    path = path.substring(0, path.lastIndexOf('.'));

    int pos = path.lastIndexOf('$');

    // is this an inner class?
    if (pos > -1) {
      String className = path.substring(pos + 1);

      // skip anonymous inner classes
      if (StringHelper.isNumber(className)) {
        return true;
      }

      path = path.replace('$', '.');
    } else if (verify) {
      try {
        // we setup a classloader with the given location and check
        // whether the location is indeed a package root
        URL[] url = new URL[] {location.toURL()};
        ClassLoader loader = new URLClassLoader(url, ClassRepository.class.getClassLoader());
        loader.loadClass(path.replace(File.separatorChar, '.'));
      } catch (ClassNotFoundException ex) {
        Object[] args = {path, location};
        Loggers.IO.l7dlog(Level.WARN, "REPOSITORY_NOT_PACKAGE_ROOT", args, null);

        return false;
      } catch (Throwable ex) {
        return false;
      }
    }

    String typeName = StringHelper.getClassName(path);

    // HACK skip obfuscated classes
    // this is necessary to make our import declaration expanding working
    // as it could easily be, that an identifier reported by the parser
    // would be wrongly taken as a type name:
    //
    //      Database d = new Database();
    //      d.shutdown();
    //      ^
    // 'd' would be reported as an identifier which is perfect but
    // lead to wrong results as there could be a class 'd.class' for
    // obfuscated librarys
    if ((typeName.length() == 1) && Character.isLowerCase(typeName.charAt(0))) {
      return true;
    }

    String packageName = StringHelper.getPackageName(path);

    // we place this marker in front of every subpackage so we know
    // where a package starts (purely for the searching facility in
    // ImportTransformation.java)
    if (!EMPTY_STRING.equals(packageName)) {
      types.add(packageName + '#');
    }

    types.add(path);

    return true;
  }
示例#3
0
  /**
   * Outputs the given string of the given type to the underlying writer.
   *
   * @param string string to write.
   * @param type type of the string.
   * @return the column offset were the string started.
   * @throws IOException if an I/O error occured.
   */
  public int print(String string, int type) throws IOException {
    int offset = 1;

    if (this.newline) {
      if (leadingIndentSize > 0) {
        _out.write(_leadingIndentSizeString);
        this.column += leadingIndentSize;
      }

      int length = this.indentLevel * this.indentSize;

      if (continuation) // use continuation indentation
      {
        length += continuationIndentSize;
      }

      switch (type) {
        case JavaTokenTypes.WS:
          {
            if (!useTabs) {
              String s = generateIndentString(length + string.length());
              this.column += s.length();
              _out.write(s);
            } else {
              if (!this.useLeadingTabs) {
                String s = generateIndentString(length + string.length());
                this.column += s.length();
                s = StringHelper.replace(s, generateIndentString(this.indentSize), TAB);
                _out.write(s);
              } else {
                String s = generateIndentString(length);
                this.column += length;
                s = StringHelper.replace(s, generateIndentString(this.indentSize), TAB);
                _out.write(s);

                this.column += string.length();
                _out.write(string);
              }
            }

            break;
          }

        default:
          {
            String s = generateIndentString(length);
            offset += length;
            this.column += (length + string.length());

            if (this.useTabs) {
              s = StringHelper.replace(s, generateIndentString(this.indentSize), TAB);
            }

            _out.write(s);
            _out.write(string);

            break;
          }
      }

      this.newline = false;
    } else {
      switch (type) {
        case JavaTokenTypes.WS:
          if (this.useTabs && !useLeadingTabs && (string.length() > this.indentSize)) {
            int tabCount = this.column / this.indentSize;
            int spacesCount = this.column - 1 - (tabCount * this.indentSize);
            this.column += string.length();

            if (spacesCount == 0) {
              string = StringHelper.replace(string, generateIndentString(this.indentSize), TAB);
              _out.write(string);
            } else {
              if (spacesCount < 0) {
                _out.write(TAB);
              }

              _out.write(TAB);

              string =
                  StringHelper.replace(
                      string.substring(this.indentSize - spacesCount),
                      generateIndentString(this.indentSize),
                      TAB);
              _out.write(string);
            }

            break;
          }

          // fall through
        default:
          offset = this.column;
          this.column += string.length();
          _out.write(string);

          break;
      }
    }

    this.last = type;

    return offset;
  }