示例#1
0
  /**
   * When a comma is found, it's formatted accordingly (spaces added after it).
   *
   * @param std the coding standard to be used
   * @param cs the contents of the document to be formatted
   * @param buf the buffer where the comma should be added
   * @param i the current index
   * @return the new index on the original doc.
   */
  private int formatForComma(
      FormatStd std,
      char[] cs,
      FastStringBuffer buf,
      int i,
      FastStringBuffer formatForCommaTempBuf) {
    formatForCommaTempBuf.clear();
    char c = '\0';
    while (i < cs.length - 1 && (c = cs[i + 1]) == ' ') {
      formatForCommaTempBuf.append(c);
      i++;
    }

    if (c == '#') {
      // Ok, we have a comment after a comma, let's handle it according to preferences.
      buf.append(',');
      if (std.spacesBeforeComment == FormatStd.DONT_HANDLE_SPACES) {
        // Note: other cases we won't handle here as it should be handled when the start of
        // a comment is found.
        buf.append(formatForCommaTempBuf);
      }
    } else {
      // Default: handle it as usual.
      if (std.spaceAfterComma) {
        buf.append(", ");
      } else {
        buf.append(',');
      }
    }
    return i;
  }
示例#2
0
    /** Check if we are still in the number */
    @Override
    public boolean isWordPart(char c) {
      // ok, we have to test for scientific notation e.g.: 10.9e10

      if ((c == 'x' || c == 'X') && buffer.length() == 1 && buffer.charAt(0) == '0') {
        // it is an hexadecimal
        buffer.append(c);
        isInHexa = true;
        return true;
      } else {
        buffer.append(c);
      }

      if (isInHexa) {
        return Character.isDigit(c)
            || c == 'a'
            || c == 'A'
            || c == 'b'
            || c == 'B'
            || c == 'c'
            || c == 'C'
            || c == 'd'
            || c == 'D'
            || c == 'e'
            || c == 'E'
            || c == 'f'
            || c == 'F';

      } else {
        return Character.isDigit(c) || c == 'e' || c == '.';
      }
    }
示例#3
0
  public void run() {
    try {
      InputStreamReader in;
      if (encoding != null) {
        in = new InputStreamReader(is, encoding);

      } else {
        in = new InputStreamReader(is);
      }
      int c;

      // small buffer because we may want to see contents as it's being written.
      // (still better than char by char).
      char[] buf = new char[80];

      if (synchronize) {
        while ((c = in.read(buf)) != -1) {
          synchronized (lock) {
            contents.append(buf, 0, c);
          }
        }
      } else {
        while ((c = in.read(buf)) != -1) {
          contents.append(buf, 0, c);
        }
      }
    } catch (Exception e) {
      // that's ok
    }
  }
  protected void saveTo(OutputStreamWriter writer, FastStringBuffer tempBuf, File pathToSave)
      throws IOException {
    synchronized (lock) {
      if (DEBUG_ADDITIONAL_INFO) {
        System.out.println(
            "Saving info "
                + this.getClass().getName()
                + " to file (size = "
                + getAllTokens().size()
                + ") "
                + pathToSave);
      }

      Map<String, Integer> dictionary = new HashMap<String, Integer>();
      tempBuf.append("-- START TREE 1\n");
      TreeIO.dumpTreeToBuffer(this.topLevelInitialsToInfo, tempBuf, dictionary);

      tempBuf.append("-- START TREE 2\n");
      TreeIO.dumpTreeToBuffer(this.innerInitialsToInfo, tempBuf, dictionary);

      FastStringBuffer buf2 = new FastStringBuffer(50 * (dictionary.size() + 4));
      TreeIO.dumpDictToBuffer(dictionary, buf2);

      // Write the dictionary before the actual trees.
      writer.write(buf2.getInternalCharsArray(), 0, buf2.length());
      buf2 = null;

      // Note: tried LZFFileInputStream from https://github.com/ning/compress
      // and Snappy from https://github.com/dain/snappy checking to see if by writing less we'd
      // get a better time but it got a bit slower (gzip was slowest, then snappy and the faster was
      // LZFFileInputStream)
      writer.write(tempBuf.getInternalCharsArray(), 0, tempBuf.length());
    }
  }
示例#5
0
 private void checkExpected(int expected) {
   FastStringBuffer buf = new FastStringBuffer(40 * comps.length);
   for (IToken t : comps) {
     buf.append(t.getRepresentation());
     buf.append(", ");
   }
   String msg = "Expected " + expected + ". Found: " + buf.toString();
   assertEquals(msg, expected, comps.length);
 }
示例#6
0
  public void run(IAction action) {
    FastStringBuffer buf = new FastStringBuffer();
    try {
      PyEdit pyEdit = getPyEdit();

      PySelection pySelection = new PySelection(pyEdit);

      IPythonNature nature = pyEdit.getPythonNature();
      File editorFile = pyEdit.getEditorFile();

      if (editorFile != null) {
        if (nature != null) {
          String mod = nature.resolveModule(editorFile);
          if (mod != null) {
            buf.append(mod);

          } else {
            // Support for external files (not in PYTHONPATH).
            buf.append(FullRepIterable.getFirstPart(editorFile.getName()));
          }
        } else {
          buf.append(FullRepIterable.getFirstPart(editorFile.getName()));
        }
      }

      List<stmtType> path =
          FastParser.parseToKnowGloballyAccessiblePath(
              pySelection.getDoc(), pySelection.getStartLineIndex());
      for (stmtType stmtType : path) {
        if (buf.length() > 0) {
          buf.append('.');
        }
        buf.append(NodeUtils.getRepresentationString(stmtType));
      }

    } catch (MisconfigurationException e1) {
      Log.log(e1);
      return;
    }

    Transfer[] dataTypes = new Transfer[] {TextTransfer.getInstance()};
    Object[] data = new Object[] {buf.toString()};

    Clipboard clipboard = new Clipboard(EditorUtils.getShell().getDisplay());
    try {
      clipboard.setContents(data, dataTypes);
    } catch (SWTError e) {
      if (e.code != DND.ERROR_CANNOT_SET_CLIPBOARD) {
        throw e;
      }
      MessageDialog.openError(
          EditorUtils.getShell(), "Error copying to clipboard.", e.getMessage());
    } finally {
      clipboard.dispose();
    }
  }
示例#7
0
 public static String getRunningName(IPath[] paths) {
   FastStringBuffer buf = new FastStringBuffer(20 * paths.length);
   for (IPath p : paths) {
     if (buf.length() > 0) {
       buf.append(" - ");
     }
     buf.append(p.lastSegment());
   }
   return buf.toString();
 }
  /**
   * @param lastMayBeMethod if true, it gets the path and accepts a method (if it is the last in the
   *     stack) if false, null is returned if a method is found.
   * @param tempStack is a temporary stack object (which may be cleared)
   * @return a tuple, where the first element is the path where the entry is located (may return
   *     null). and the second element is a boolean that indicates if the last was actually a method
   *     or not.
   */
  private Tuple<String, Boolean> getPathToRoot(
      ASTEntry entry, boolean lastMayBeMethod, boolean acceptAny, FastStack<SimpleNode> tempStack) {
    if (entry.parent == null) {
      return null;
    }
    // just to be sure that it's empty
    tempStack.clear();

    boolean lastIsMethod = false;
    // if the last 'may be a method', in this case, we have to remember that it will actually be the
    // first one
    // to be analyzed.

    // let's get the stack
    while (entry.parent != null) {
      if (entry.parent.node instanceof ClassDef) {
        tempStack.push(entry.parent.node);

      } else if (entry.parent.node instanceof FunctionDef) {
        if (!acceptAny) {
          if (lastIsMethod) {
            // already found a method
            return null;
          }

          if (!lastMayBeMethod) {
            return null;
          }

          // ok, the last one may be a method... (in this search, it MUST be the first one...)
          if (tempStack.size() != 0) {
            return null;
          }
        }

        // ok, there was a class, so, let's go and set it
        tempStack.push(entry.parent.node);
        lastIsMethod = true;

      } else {
        return null;
      }
      entry = entry.parent;
    }

    // now that we have the stack, let's make it into a path...
    FastStringBuffer buf = new FastStringBuffer();
    while (tempStack.size() > 0) {
      if (buf.length() > 0) {
        buf.append(".");
      }
      buf.append(NodeUtils.getRepresentationString(tempStack.pop()));
    }
    return new Tuple<String, Boolean>(buf.toString(), lastIsMethod);
  }
 /**
  * @param buffer
  * @param name
  */
 private void entrySetToString(FastStringBuffer buffer, Set<Entry<String, Set<IInfo>>> name) {
   synchronized (lock) {
     for (Entry<String, Set<IInfo>> entry : name) {
       Set<IInfo> value = entry.getValue();
       for (IInfo info : value) {
         buffer.append(info.toString());
         buffer.append("\n");
       }
     }
   }
 }
示例#10
0
 /** @see org.eclipse.jface.text.rules.IWordDetector#isWordStart(char) */
 @Override
 public boolean isWordStart(char c) {
   isInHexa = false;
   buffer.clear();
   buffer.append(c);
   return Character.isDigit(c);
 }
  /**
   * The line delimiters must match the platform for the bolds to be correct, so, in this function
   * we remove the ones existing and add the ones dependent on the platform
   */
  protected String correctLineDelimiters(String str) {
    FastStringBuffer buf = new FastStringBuffer();
    for (String s : StringUtils.splitInLines(str)) {

      boolean found = false;
      while (s.endsWith("\r") || s.endsWith("\n")) {
        found = true;
        s = s.substring(0, s.length() - 1);
      }
      buf.append(s);
      if (found) {
        buf.append(LINE_DELIM);
      }
    }
    str = buf.toString();
    return str;
  }
示例#12
0
  /** Handles the case where we found a '#' in the code. */
  private int handleComment(
      FormatStd std,
      char[] cs,
      FastStringBuffer buf,
      FastStringBuffer tempBuf,
      ParsingUtils parsingUtils,
      int i) {
    if (std.spacesBeforeComment != FormatStd.DONT_HANDLE_SPACES) {
      for (int j = i - 1; j >= 0; j--) {
        char cj = cs[j];
        if (cj == '\t' || cj == ' ') {
          continue;
        }
        // Ok, found a non-whitespace -- if it's not a new line, we're after some
        // code, in which case we have to put the configured amount of spaces.
        if (cj != '\r' && cj != '\n') {
          buf.rightTrim();
          buf.appendN(' ', std.spacesBeforeComment);
        }
        break;
      }
    }

    tempBuf.clear();
    i = parsingUtils.eatComments(tempBuf, i);
    if (std.trimLines) {
      String endLine = "";
      if (tempBuf.endsWith("\r\n")) {
        endLine = "\r\n";
        tempBuf.deleteLastChars(2);
      } else if (tempBuf.endsWith('\r') || tempBuf.endsWith('\n')) {
        endLine += tempBuf.lastChar();
        tempBuf.deleteLast();
      }
      tempBuf.rightTrim();
      tempBuf.append(endLine);
    }

    formatComment(std, tempBuf);

    buf.append(tempBuf);
    return i;
  }
示例#13
0
 @Override
 public String toString() {
   if (file != null) {
     FastStringBuffer ret = new FastStringBuffer(name, 40);
     ret.append(" - ");
     ret.appendObject(file);
     return ret.toString();
   }
   return name;
 }
示例#14
0
  public static void buildKeysForRegularEntries(
      IProgressMonitor monitor,
      ModulesFoundStructure modulesFound,
      PyPublicTreeMap<ModulesKey, ModulesKey> keys,
      boolean includeOnlySourceModules) {
    String[] dottedValidSourceFiles = FileTypesPreferencesPage.getDottedValidSourceFiles();

    int j = 0;
    FastStringBuffer buffer = new FastStringBuffer();
    // now, create in memory modules for all the loaded files (empty modules).
    for (Iterator<Map.Entry<File, String>> iterator =
            modulesFound.regularModules.entrySet().iterator();
        iterator.hasNext() && monitor.isCanceled() == false;
        j++) {
      Map.Entry<File, String> entry = iterator.next();
      String m = entry.getValue();

      if (m != null) {
        if (j % 20 == 0) {
          // no need to report all the time (that's pretty fast now)
          buffer.clear();
          monitor.setTaskName(buffer.append("Module resolved: ").append(m).toString());
          monitor.worked(1);
        }

        // we don't load them at this time.
        File f = entry.getKey();

        if (includeOnlySourceModules) {
          // check if we should include only source modules
          if (!PythonPathHelper.isValidSourceFile(f.getName())) {
            continue;
          }
        }
        ModulesKey modulesKey = new ModulesKey(m, f);

        // no conflict (easy)
        if (!keys.containsKey(modulesKey)) {
          keys.put(modulesKey, modulesKey);

        } else {
          // we have a conflict, so, let's resolve which one to keep (the old one or this one)
          if (PythonPathHelper.isValidSourceFile(f.getName(), dottedValidSourceFiles)) {
            // source files have priority over other modules (dlls) -- if both are source, there is
            // no real way to resolve
            // this priority, so, let's just add it over.
            keys.put(modulesKey, modulesKey);
          }
        }
      }
    }
  }
示例#15
0
 /** Gets the reader content as a String */
 private static String getString(Reader reader) {
   FastStringBuffer buf = new FastStringBuffer();
   char[] buffer = new char[1024];
   int count;
   try {
     while ((count = reader.read(buffer)) != -1) {
       buf.append(buffer, 0, count);
     }
   } catch (IOException e) {
     return null;
   }
   return buf.toString();
 }
示例#16
0
文件: TreeIO.java 项目: fabioz/Pydev
  /** Dict format is the following: -- START DICTIONARY dictionary size name=integer */
  public static void dumpDictToBuffer(Map<String, Integer> strToInt, FastStringBuffer buf2) {
    Iterator<Entry<String, Integer>> it = strToInt.entrySet().iterator();

    buf2.append("-- START DICTIONARY\n");
    buf2.append(strToInt.size());
    buf2.append('\n');
    while (it.hasNext()) {
      Entry<String, Integer> next = it.next();
      buf2.append(next.getValue());
      buf2.append('=');
      buf2.append(next.getKey());
      buf2.append('\n');
    }
    buf2.append("-- END DICTIONARY\n");
  }
示例#17
0
  /**
   * Creates the errors that are related to a bad indentation (number of space chars is not ok).
   *
   * @param monitor
   */
  private static void createBadIndentForSpacesMessages(
      IDocument doc,
      IAnalysisPreferences analysisPrefs,
      IIndentPrefs indentPrefs,
      ArrayList<IMessage> ret,
      List<Tuple3<String, Integer, Boolean>> validsAre,
      IProgressMonitor monitor) {

    int tabWidth = indentPrefs.getTabWidth();
    // if we're analyzing the spaces, let's mark invalid indents (tabs are not searched for those
    // because
    // a tab always marks a full indent).

    FastStringBuffer buffer = new FastStringBuffer();
    for (Tuple3<String, Integer, Boolean> indentation : validsAre) {
      if (monitor.isCanceled()) {
        return;
      }

      if (!indentation
          .o3) { // if it does not have more contents (its only whitespaces), let's keep on going!
        continue;
      }
      String indentStr = indentation.o1;
      if (indentStr.indexOf("\t") != -1) {
        continue; // the ones that appear in tabs and spaces should not be analyzed here (they'll
        // have their own error messages).
      }

      int lenFound = indentStr.length();
      int extraChars = lenFound % tabWidth;
      if (extraChars != 0) {

        Integer offset = indentation.o2;
        int startLine = PySelection.getLineOfOffset(doc, offset) + 1;
        int startCol = 1;
        int endCol = startCol + lenFound;

        buffer.clear();
        ret.add(
            new Message(
                IAnalysisPreferences.TYPE_INDENTATION_PROBLEM,
                buffer.append("Bad Indentation (").append(lenFound).append(" spaces)").toString(),
                startLine,
                startLine,
                startCol,
                endCol,
                analysisPrefs));
      }
    }
  }
  protected void save(File persistingLocation) {
    try {
      FileOutputStream stream = new FileOutputStream(persistingLocation);
      OutputStreamWriter writer = new OutputStreamWriter(stream);
      try {
        FastStringBuffer tempBuf = new FastStringBuffer();
        tempBuf.append("-- VERSION_");
        tempBuf.append(AbstractAdditionalTokensInfo.version);
        tempBuf.append('\n');
        writer.write(tempBuf.getInternalCharsArray(), 0, tempBuf.length());
        tempBuf.clear();

        saveTo(writer, tempBuf, persistingLocation);
      } finally {
        try {
          writer.close();
        } finally {
          stream.close();
        }
      }
    } catch (Exception e) {
      Log.log(e);
    }
  }
示例#19
0
 public String getLastWord() {
   FastStringBuffer lastWordBuf = new FastStringBuffer(this.count);
   int i;
   // skip whitespaces in the end
   for (i = this.count - 1; i >= 0; i--) {
     if (!Character.isWhitespace(this.value[i])) {
       break;
     }
   }
   // actual word
   for (; i >= 0; i--) {
     if (Character.isWhitespace(this.value[i])) {
       break;
     }
     lastWordBuf.append(this.value[i]);
   }
   lastWordBuf.reverse();
   return lastWordBuf.toString();
 }
  @Override
  public String toString() {
    synchronized (lock) {
      FastStringBuffer buffer = new FastStringBuffer();
      buffer.append("AdditionalInfo{");

      buffer.append("topLevel=[");
      entrySetToString(buffer, this.topLevelInitialsToInfo.entrySet());
      buffer.append("]\n");
      buffer.append("inner=[");
      entrySetToString(buffer, this.innerInitialsToInfo.entrySet());
      buffer.append("]");

      buffer.append("}");
      return buffer.toString();
    }
  }
示例#21
0
  /**
   * copied from org.eclipse.jdt.internal.launching.StandardVMRunner
   *
   * @param args - other arguments to be added to the command line (may be null)
   * @return
   */
  public static String getArgumentsAsStr(String[] commandLine, String... args) {
    if (args != null && args.length > 0) {
      String[] newCommandLine = new String[commandLine.length + args.length];
      System.arraycopy(commandLine, 0, newCommandLine, 0, commandLine.length);
      System.arraycopy(args, 0, newCommandLine, commandLine.length, args.length);
      commandLine = newCommandLine;
    }

    if (commandLine.length < 1) return ""; // $NON-NLS-1$
    FastStringBuffer buf = new FastStringBuffer();
    FastStringBuffer command = new FastStringBuffer();
    for (int i = 0; i < commandLine.length; i++) {
      if (commandLine[i] == null) {
        continue; // ignore nulls (changed from original code)
      }

      buf.append(' ');
      char[] characters = commandLine[i].toCharArray();
      command.clear();
      boolean containsSpace = false;
      for (int j = 0; j < characters.length; j++) {
        char character = characters[j];
        if (character == '\"') {
          command.append('\\');
        } else if (character == ' ') {
          containsSpace = true;
        }
        command.append(character);
      }
      if (containsSpace) {
        buf.append('\"');
        buf.append(command.toString());
        buf.append('\"');
      } else {
        buf.append(command.toString());
      }
    }
    return buf.toString();
  }
示例#22
0
文件: TreeIO.java 项目: fabioz/Pydev
  /** Tree is written as: line 1= tree size cub|2|CubeColourDialog!13&999@CUBIC!263@cube!202&999@ */
  public static void dumpTreeToBuffer(
      SortedMap<String, Set<IInfo>> tree, FastStringBuffer tempBuf, Map<String, Integer> strToInt) {
    Set<Entry<String, Set<IInfo>>> entrySet = tree.entrySet();
    Iterator<Entry<String, Set<IInfo>>> it = entrySet.iterator();
    tempBuf.append(entrySet.size());
    tempBuf.append('\n');
    while (it.hasNext()) {
      Entry<String, Set<IInfo>> next = it.next();
      tempBuf.append(next.getKey());
      Set<IInfo> value = next.getValue();

      tempBuf.append('|');
      tempBuf.append(value.size());
      tempBuf.append('|');

      Iterator<IInfo> it2 = value.iterator();
      Integer integer;
      while (it2.hasNext()) {
        IInfo info = it2.next();
        tempBuf.append(info.getName());
        tempBuf.append('!');

        String path = info.getPath();
        if (path != null) {
          integer = strToInt.get(path);
          if (integer == null) {
            integer = strToInt.size() + 1;
            strToInt.put(path, integer);
          }
          tempBuf.append(integer);
          tempBuf.append('&');
        }

        String modName = info.getDeclaringModuleName();

        integer = strToInt.get(modName);
        if (integer == null) {
          integer = strToInt.size() + 1;
          strToInt.put(modName, integer);
        }

        int v = integer << 3;
        v |= info.getType();
        tempBuf.append(v); // Write a single for name+type

        tempBuf.append('@');
      }
      tempBuf.append('\n');
    }
    tempBuf.append("-- END TREE\n");
  }
示例#23
0
  /**
   * This method formats a string given some standard.
   *
   * @param str the string to be formatted
   * @param std the standard to be used
   * @param parensLevel the level of the parenthesis available.
   * @return a new (formatted) string
   * @throws SyntaxErrorException
   */
  private String formatStr(
      String str, FormatStd std, int parensLevel, String delimiter, boolean throwSyntaxError)
      throws SyntaxErrorException {
    char[] cs = str.toCharArray();
    FastStringBuffer buf = new FastStringBuffer();

    // Temporary buffer for some operations. Must always be cleared before it's used.
    FastStringBuffer tempBuf = new FastStringBuffer();

    ParsingUtils parsingUtils = ParsingUtils.create(cs, throwSyntaxError);
    char lastChar = '\0';
    for (int i = 0; i < cs.length; i++) {
      char c = cs[i];

      switch (c) {
        case '\'':
        case '"':
          // ignore literals and multi-line literals, including comments...
          i = parsingUtils.eatLiterals(buf, i, std.trimMultilineLiterals);
          break;

        case '#':
          i = handleComment(std, cs, buf, tempBuf, parsingUtils, i);
          break;

        case ',':
          i = formatForComma(std, cs, buf, i, tempBuf);
          break;

        case '(':
          i =
              formatForPar(
                  parsingUtils, cs, i, std, buf, parensLevel + 1, delimiter, throwSyntaxError);
          break;

          // Things to treat:
          // +, -, *, /, %
          // ** // << >>
          // <, >, !=, <>, <=, >=, //=, *=, /=,
          // & ^ ~ |
        case '*':
          // for *, we also need to treat when it's used in varargs, kwargs and list expansion
          boolean isOperator = false;
          for (int j = buf.length() - 1; j >= 0; j--) {
            char localC = buf.charAt(j);
            if (Character.isWhitespace(localC)) {
              continue;
            }
            if (localC == '(' || localC == ',') {
              // it's not an operator, but vararg. kwarg or list expansion
            }
            if (Character.isJavaIdentifierPart(localC)) {
              // ok, there's a chance that it can be an operator, but we still have to check
              // the chance that it's a wild import
              tempBuf.clear();
              while (Character.isJavaIdentifierPart(localC)) {
                tempBuf.append(localC);
                j--;
                if (j < 0) {
                  break; // break while
                }
                localC = buf.charAt(j);
              }
              String reversed = tempBuf.reverse().toString();
              if (!reversed.equals("import") && !reversed.equals("lambda")) {
                isOperator = true;
              }
            }
            if (localC == '\'' || localC == ')' || localC == ']') {
              isOperator = true;
            }

            // If it got here (i.e.: not whitespace), get out of the for loop.
            break;
          }
          if (!isOperator) {
            buf.append('*');
            break; // break switch
          }
          // Otherwise, FALLTHROUGH

        case '+':
        case '-':
          if (c == '-' || c == '+') { // could also be *

            // handle exponentials correctly: e.g.: 1e-6 cannot have a space
            tempBuf.clear();
            boolean started = false;

            for (int j = buf.length() - 1; ; j--) {
              if (j < 0) {
                break;
              }
              char localC = buf.charAt(j);
              if (localC == ' ' || localC == '\t') {
                if (!started) {
                  continue;
                } else {
                  break;
                }
              }
              started = true;
              if (Character.isJavaIdentifierPart(localC) || localC == '.') {
                tempBuf.append(localC);
              } else {
                break; // break for
              }
            }
            boolean isExponential = true;
            String partialNumber = tempBuf.reverse().toString();
            int partialLen = partialNumber.length();
            if (partialLen < 2 || !Character.isDigit(partialNumber.charAt(0))) {
              // at least 2 chars: the number and the 'e'
              isExponential = false;
            } else {
              // first char checked... now, if the last is an 'e', we must leave it together no
              // matter what
              if (partialNumber.charAt(partialLen - 1) != 'e'
                  && partialNumber.charAt(partialLen - 1) != 'E') {
                isExponential = false;
              }
            }
            if (isExponential) {
              buf.rightTrim();
              buf.append(c);
              // skip the next whitespaces from the buffer
              int initial = i;
              do {
                i++;
              } while (i < cs.length && (c = cs[i]) == ' ' || c == '\t');
              if (i > initial) {
                i--; // backup 1 because we walked 1 too much.
              }
              break; // break switch
            }
            // Otherwise, FALLTHROUGH
          }

        case '/':
        case '%':
        case '<':
        case '>':
        case '!':
        case '&':
        case '^':
        case '~':
        case '|':
          i = handleOperator(std, cs, buf, parsingUtils, i, c);
          c = cs[i];
          break;

          // check for = and == (other cases that have an = as the operator should already be
          // treated)
        case '=':
          if (i < cs.length - 1 && cs[i + 1] == '=') {
            // if == handle as if a regular operator
            i = handleOperator(std, cs, buf, parsingUtils, i, c);
            c = cs[i];
            break;
          }

          while (buf.length() > 0 && buf.lastChar() == ' ') {
            buf.deleteLast();
          }

          boolean surroundWithSpaces = std.operatorsWithSpace;
          if (parensLevel > 0) {
            surroundWithSpaces = std.assignWithSpaceInsideParens;
          }

          // add space before
          if (surroundWithSpaces) {
            buf.append(' ');
          }

          // add the operator and the '='
          buf.append('=');

          // add space after
          if (surroundWithSpaces) {
            buf.append(' ');
          }

          i = parsingUtils.eatWhitespaces(null, i + 1);
          break;

        default:
          if (c == '\r' || c == '\n') {
            if (lastChar == ',' && std.spaceAfterComma && buf.lastChar() == ' ') {
              buf.deleteLast();
            }
            if (std.trimLines) {
              buf.rightTrim();
            }
          }
          buf.append(c);
      }
      lastChar = c;
    }
    if (parensLevel == 0 && std.trimLines) {
      buf.rightTrim();
    }
    return buf.toString();
  }
示例#24
0
  public List<IMessage> getMessages(
      SourceModule module,
      IDocument document,
      IProgressMonitor monitor,
      IAnalysisPreferences prefs) {
    try {

      if (prefs.getSeverityForType(IAnalysisPreferences.TYPE_PEP8) < IMarker.SEVERITY_WARNING) {
        return messages;
      }
      this.prefs = prefs;
      this.document = document;
      messageToIgnore = prefs.getRequiredMessageToIgnore(IAnalysisPreferences.TYPE_PEP8);
      File pep8Loc = JythonModules.getPep8Location();

      if (pep8Loc == null) {
        Log.log("Unable to get pep8 module.");
        return messages;
      }

      IAdaptable projectAdaptable = prefs.getProjectAdaptable();
      if (AnalysisPreferencesPage.useSystemInterpreter(projectAdaptable)) {
        String parameters = AnalysisPreferencesPage.getPep8CommandLineAsStr(projectAdaptable);
        String output =
            PyFormatStd.runWithPep8BaseScript(document.get(), parameters, "pep8.py", "");
        List<String> splitInLines = StringUtils.splitInLines(output, false);

        for (String line : splitInLines) {
          try {
            List<String> lst = StringUtils.split(line, ':', 4);
            int lineNumber = Integer.parseInt(lst.get(1));
            int offset = Integer.parseInt(lst.get(2)) - 1;
            String text = lst.get(3);
            this.reportError(lineNumber, offset, text, null);
          } catch (Exception e) {
            Log.log("Error parsing line: " + line, e);
          }
        }
        return messages;
      }

      String[] pep8CommandLine = AnalysisPreferencesPage.getPep8CommandLine(projectAdaptable);
      FastStringBuffer args = new FastStringBuffer(pep8CommandLine.length * 20);
      for (String string : pep8CommandLine) {
        args.append(',').append("r'").append(string).append('\'');
      }

      // It's important that the interpreter is created in the Thread and not outside the thread
      // (otherwise
      // it may be that the output ends up being shared, which is not what we want.)
      boolean useConsole = AnalysisPreferencesPage.useConsole(projectAdaptable);
      IPythonInterpreter interpreter = JythonPlugin.newPythonInterpreter(useConsole, false);
      String file = StringUtils.replaceAllSlashes(module.getFile().getAbsolutePath());
      interpreter.set("visitor", this);

      List<String> splitInLines = StringUtils.splitInLines(document.get());
      interpreter.set("lines", splitInLines);
      PyObject tempReportError = reportError;
      if (tempReportError != null) {
        interpreter.set("ReportError", tempReportError);
      } else {
        interpreter.set("ReportError", Py.None);
      }
      PyObject pep8Module = JythonModules.getPep8Module(interpreter);
      interpreter.set("pep8", pep8Module);

      String formatted = StringUtils.format(EXECUTE_PEP8, file, args.toString(), file);
      interpreter.exec(formatted);
      if (reportError == null) {
        synchronized (lock) {
          if (reportError == null) {
            reportError = interpreter.get("ReportError");
          }
        }
      }

    } catch (Exception e) {
      Log.log("Error analyzing: " + module, e);
    }

    return messages;
  }
示例#25
0
  /**
   * @param operation
   * @return
   * @throws IOException
   */
  private FastStringBuffer read(IProgressMonitor monitor) throws IOException {
    synchronized (ioLock) {
      if (finishedForGood) {
        throw new RuntimeException(
            "Shells are already finished for good, so, it is an invalid state to try to read from it.");
      }
      if (inStart) {
        throw new RuntimeException(
            "The shell is still not completely started, so, it is an invalid state to try to read from it.");
      }
      if (!isConnected) {
        throw new RuntimeException(
            "The shell is still not connected, so, it is an invalid state to try to read from it.");
      }
      if (isInRead) {
        throw new RuntimeException(
            "The shell is already in read mode, so, it is an invalid state to try to read from it.");
      }
      if (isInWrite) {
        throw new RuntimeException(
            "The shell is already in write mode, so, it is an invalid state to try to read from it.");
      }

      isInRead = true;

      try {
        FastStringBuffer str = new FastStringBuffer(AbstractShell.BUFFER_SIZE);
        byte[] b = new byte[AbstractShell.BUFFER_SIZE];
        while (true) {

          int len = this.socket.getInputStream().read(b);
          if (len == 0) {
            break;
          }

          String s = new String(b, 0, len);
          str.append(s);

          if (str.indexOf("END@@") != -1) {
            break;
          } else {
            sleepALittle(10);
          }
        }

        str.replaceFirst("@@COMPLETIONS", "");
        // remove END@@
        try {
          if (str.indexOf("END@@") != -1) {
            str.setCount(str.indexOf("END@@"));
            return str;
          } else {
            throw new RuntimeException("Couldn't find END@@ on received string.");
          }
        } catch (RuntimeException e) {
          if (str.length() > 500) {
            str.setCount(499)
                .append("...(continued)..."); // if the string gets too big, it can crash Eclipse...
          }
          Log.log(IStatus.ERROR, ("ERROR WITH STRING:" + str), e);
          return new FastStringBuffer();
        }
      } finally {
        isInRead = false;
      }
    }
  }
示例#26
0
  /**
   * Handles having an operator
   *
   * @param std the coding standard to be used
   * @param cs the contents of the string
   * @param buf the buffer where the contents should be added
   * @param parsingUtils helper to get the contents
   * @param i current index
   * @param c current char
   * @return the new index after handling the operator
   */
  private int handleOperator(
      FormatStd std, char[] cs, FastStringBuffer buf, ParsingUtils parsingUtils, int i, char c) {
    // let's discover if it's an unary operator (~ + -)
    boolean isUnaryWithContents = true;

    boolean isUnary = false;
    boolean changeWhitespacesBefore = true;
    if (c == '~' || c == '+' || c == '-') {
      // could be an unary operator...
      String trimmedLastWord = buf.getLastWord().trim();
      isUnary =
          trimmedLastWord.length() == 0 || PySelection.ALL_KEYWORD_TOKENS.contains(trimmedLastWord);

      if (!isUnary) {
        for (char itChar : buf.reverseIterator()) {
          if (itChar == ' ' || itChar == '\t') {
            continue;
          }

          switch (itChar) {
            case '[':
            case '{':
            case '=':
              changeWhitespacesBefore = false;

            case '(':
            case ':':
              isUnaryWithContents = false;

            case '>':
            case '<':

            case '-':
            case '+':
            case '~':

            case '*':
            case '/':
            case '%':
            case '!':
            case '&':
            case '^':
            case '|':
            case ',':
              isUnary = true;
          }
          break;
        }
      } else {
        isUnaryWithContents = buf.length() > 0;
      }
    }

    if (!isUnary) {
      // We don't want to change whitespaces before in a binary operator that is in a new line.
      for (char ch : buf.reverseIterator()) {
        if (!Character.isWhitespace(ch)) {
          break;
        }
        if (ch == '\r' || ch == '\n') {
          changeWhitespacesBefore = false;
          break;
        }
      }
    }

    if (changeWhitespacesBefore) {
      while (buf.length() > 0 && (buf.lastChar() == ' ' || buf.lastChar() == ' ')) {
        buf.deleteLast();
      }
    }

    boolean surroundWithSpaces = std.operatorsWithSpace;

    if (changeWhitespacesBefore) {
      // add spaces before
      if (isUnaryWithContents && surroundWithSpaces) {
        buf.append(' ');
      }
    }

    char localC = c;
    char prev = '\0';
    boolean backOne = true;
    while (isOperatorPart(localC, prev)) {
      buf.append(localC);
      prev = localC;
      i++;
      if (i == cs.length) {
        break;
      }
      localC = cs[i];
      if (localC == '=') {
        // when we get to an assign, we have found a full stmt (with assign) -- e.g.: a \\=  a += a
        // ==
        buf.append(localC);
        backOne = false;
        break;
      }
    }
    if (backOne) {
      i--;
    }

    // add space after only if it's not unary
    if (!isUnary && surroundWithSpaces) {
      buf.append(' ');
    }

    i = parsingUtils.eatWhitespaces(null, i + 1);
    return i;
  }
示例#27
0
  /**
   * Formats the contents for when a parenthesis is found (so, go until the closing parens and
   * format it accordingly)
   *
   * @param throwSyntaxError
   * @throws SyntaxErrorException
   */
  private int formatForPar(
      final ParsingUtils parsingUtils,
      final char[] cs,
      final int i,
      final FormatStd std,
      final FastStringBuffer buf,
      final int parensLevel,
      final String delimiter,
      boolean throwSyntaxError)
      throws SyntaxErrorException {
    char c = ' ';
    FastStringBuffer locBuf = new FastStringBuffer();

    int j = i + 1;
    int start = j;
    int end = start;
    while (j < cs.length && (c = cs[j]) != ')') {

      j++;

      if (c == '\'' || c == '"') { // ignore comments or multiline comments...
        j = parsingUtils.eatLiterals(null, j - 1, std.trimMultilineLiterals) + 1;
        end = j;

      } else if (c == '#') {
        j = parsingUtils.eatComments(null, j - 1) + 1;
        end = j;

      } else if (c == '(') { // open another par.
        if (end > start) {
          locBuf.append(cs, start, end - start);
          start = end;
        }
        j =
            formatForPar(
                    parsingUtils,
                    cs,
                    j - 1,
                    std,
                    locBuf,
                    parensLevel + 1,
                    delimiter,
                    throwSyntaxError)
                + 1;
        start = j;

      } else {
        end = j;
      }
    }
    if (end > start) {
      locBuf.append(cs, start, end - start);
      start = end;
    }

    if (c == ')') {
      // Now, when a closing parens is found, let's see the contents of the line where that parens
      // was found
      // and if it's only whitespaces, add all those whitespaces (to handle the following case:
      // a(a,
      //  b
      //   ) <-- we don't want to change this one.
      char c1;
      FastStringBuffer buf1 = new FastStringBuffer();

      if (locBuf.indexOf('\n') != -1 || locBuf.indexOf('\r') != -1) {
        for (int k = locBuf.length();
            k > 0 && (c1 = locBuf.charAt(k - 1)) != '\n' && c1 != '\r';
            k--) {
          buf1.insert(0, c1);
        }
      }

      String formatStr =
          formatStr(trim(locBuf).toString(), std, parensLevel, delimiter, throwSyntaxError);
      FastStringBuffer formatStrBuf = trim(new FastStringBuffer(formatStr, 10));

      String closing = ")";
      if (buf1.length() > 0 && PySelection.containsOnlyWhitespaces(buf1.toString())) {
        formatStrBuf.append(buf1);

      } else if (std.parametersWithSpace) {
        closing = " )";
      }

      if (std.parametersWithSpace) {
        if (formatStrBuf.length() == 0) {
          buf.append("()");

        } else {
          buf.append("( ");
          buf.append(formatStrBuf);
          buf.append(closing);
        }
      } else {
        buf.append('(');
        buf.append(formatStrBuf);
        buf.append(closing);
      }
      return j;
    } else {
      if (throwSyntaxError) {
        throw new SyntaxErrorException("No closing ')' found.");
      }
      // we found no closing parens but we finished looking already, so, let's just add anything
      // without
      // more formatting...
      buf.append('(');
      buf.append(locBuf);
      return j;
    }
  }
示例#28
0
  public void saveToFile(File workspaceMetadataFile) {
    if (workspaceMetadataFile.exists() && !workspaceMetadataFile.isDirectory()) {
      try {
        FileUtils.deleteFile(workspaceMetadataFile);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
    if (!workspaceMetadataFile.exists()) {
      workspaceMetadataFile.mkdirs();
    }

    File modulesKeysFile = new File(workspaceMetadataFile, "modulesKeys");
    File pythonpatHelperFile = new File(workspaceMetadataFile, "pythonpath");
    FastStringBuffer buf;
    HashMap<String, Integer> commonTokens = new HashMap<String, Integer>();

    synchronized (modulesKeysLock) {
      buf = new FastStringBuffer(this.modulesKeys.size() * 50);
      buf.append(MODULES_MANAGER_V2);

      for (Iterator<ModulesKey> iter = this.modulesKeys.keySet().iterator(); iter.hasNext(); ) {
        ModulesKey next = iter.next();
        buf.append(next.name);
        if (next.file != null) {
          buf.append("|");
          if (next instanceof ModulesKeyForZip) {
            ModulesKeyForZip modulesKeyForZip = (ModulesKeyForZip) next;
            if (modulesKeyForZip.zipModulePath != null) {
              String fileStr = next.file.toString();
              Integer t = commonTokens.get(fileStr);
              if (t == null) {
                t = commonTokens.size();
                commonTokens.put(fileStr, t);
              }
              buf.append(t);
              buf.append("|");

              buf.append(modulesKeyForZip.zipModulePath);
              buf.append("|");
              buf.append(modulesKeyForZip.isFile ? '1' : '0');
            }
          } else {
            buf.append(next.file.toString());
          }
        }
        buf.append('\n');
      }
    }
    if (commonTokens.size() > 0) {
      FastStringBuffer header = new FastStringBuffer(buf.length() + (commonTokens.size() * 50));
      header.append(MODULES_MANAGER_V2);
      header.append("--COMMON--\n");
      for (Map.Entry<String, Integer> entries : commonTokens.entrySet()) {
        header.append(entries.getValue());
        header.append('=');
        header.append(entries.getKey());
        header.append('\n');
      }
      header.append("--END-COMMON--\n");
      header.append(buf);
      buf = header;
    }
    FileUtils.writeStrToFile(buf.toString(), modulesKeysFile);

    this.pythonPathHelper.saveToFile(pythonpatHelperFile);
  }