/** Check if we are still in the number */ 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 == '.'; } }
/** * We just want to trim whitespaces, not newlines! * * @param locBuf the buffer to be trimmed * @return the same buffer passed as a parameter */ private FastStringBuffer trim(FastStringBuffer locBuf) { while (locBuf.length() > 0 && (locBuf.firstChar() == ' ' || locBuf.firstChar() == '\t')) { locBuf.deleteCharAt(0); } rtrim(locBuf); return locBuf; }
private void rightTrimIfNeeded(FormatStd std, FastStringBuffer buf) { if (std.trimLines) { char tempC; while (buf.length() > 0 && ((tempC = buf.lastChar()) == ' ' || tempC == '\t')) { buf.deleteLast(); } } }
/** * @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 boolen 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, List<IInfo>>> name) { synchronized (lock) { for (Entry<String, List<IInfo>> entry : name) { List<IInfo> value = entry.getValue(); for (IInfo info : value) { buffer.append(info.toString()); buffer.append("\n"); } } } }
/** * 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) { while (i < cs.length - 1 && (cs[i + 1]) == ' ') { i++; } if (std.spaceAfterComma) { buf.append(", "); } else { buf.append(','); } return i; }
/** ThreadRun event processing */ private void processThreadRun(String payload) { try { Tuple<String, String> threadIdAndReason = getThreadIdAndReason(payload); int resumeReason = DebugEvent.UNSPECIFIED; try { int raw_reason = Integer.parseInt(threadIdAndReason.o2); if (raw_reason == AbstractDebuggerCommand.CMD_STEP_OVER) resumeReason = DebugEvent.STEP_OVER; else if (raw_reason == AbstractDebuggerCommand.CMD_STEP_RETURN) resumeReason = DebugEvent.STEP_RETURN; else if (raw_reason == AbstractDebuggerCommand.CMD_STEP_INTO) resumeReason = DebugEvent.STEP_INTO; else if (raw_reason == AbstractDebuggerCommand.CMD_RUN_TO_LINE) resumeReason = DebugEvent.UNSPECIFIED; else if (raw_reason == AbstractDebuggerCommand.CMD_SET_NEXT_STATEMENT) resumeReason = DebugEvent.UNSPECIFIED; else if (raw_reason == AbstractDebuggerCommand.CMD_THREAD_RUN) resumeReason = DebugEvent.CLIENT_REQUEST; else { PydevDebugPlugin.log(IStatus.ERROR, "Unexpected resume reason code", null); resumeReason = DebugEvent.UNSPECIFIED; } } catch (NumberFormatException e) { // expected, when pydevd reports "None" resumeReason = DebugEvent.UNSPECIFIED; } String threadID = threadIdAndReason.o1; PyThread t = (PyThread) findThreadByID(threadID); if (t != null) { t.setSuspended(false, null); fireEvent(new DebugEvent(t, DebugEvent.RESUME, resumeReason)); } else { FastStringBuffer buf = new FastStringBuffer(); for (PyThread thread : threads) { if (buf.length() > 0) { buf.append(", "); } buf.append("id: " + thread.getId()); } String msg = "Unable to find thread: " + threadID + " available: " + buf; PydevDebugPlugin.log(IStatus.ERROR, msg, new RuntimeException(msg)); } } catch (CoreException e1) { Log.log(e1); } }
/** * Recalculates indent prefixes based upon preferences * * <p>we hold onto the same array SourceViewer has, and write directly into it. This is because * there is no way to tell SourceViewer that indent prefixes have changed. And we need this * functionality when user resets the tabs vs. spaces preference */ public void resetIndentPrefixes() { IPreferenceStore prefs = PydevPlugin.getDefault().getPreferenceStore(); int tabWidth = DefaultIndentPrefs.getStaticTabWidth(); FastStringBuffer spaces = new FastStringBuffer(8); for (int i = 0; i < tabWidth; i++) { spaces.append(" "); } boolean spacesFirst = prefs.getBoolean(PydevEditorPrefs.SUBSTITUTE_TABS) && !(getPyAutoIndentStrategy()).getIndentPrefs().getForceTabs(); if (spacesFirst) { indentPrefixes[0] = spaces.toString(); indentPrefixes[1] = "\t"; } else { indentPrefixes[0] = "\t"; indentPrefixes[1] = spaces.toString(); } }
@Override public Tuple<Integer, Integer> perform(final PySelection ps) throws BadLocationException { ps.selectCompleteLine(); final boolean shouldAddCommentSign = PyToggleComment.allLinesStartWithCommentSign(ps) == false; String endLineDelim = ps.getEndLineDelim(); int endLineIndex = ps.getEndLineIndex(); int startLineIndex = ps.getStartLineIndex(); final FastStringBuffer sb = new FastStringBuffer(ps.getSelLength() + (endLineIndex - startLineIndex) + 10); for (int i = startLineIndex, n = endLineIndex; i <= n; i++) { final String line = ps.getLine(i); if (shouldAddCommentSign) { sb.append("#"); sb.append(line); } else { // remove comment sign sb.append(line.replaceFirst("#", "")); } // add a new line if we're not in the last line. sb.append((i < endLineIndex ? endLineDelim : "")); } final int start = ps.getStartLine().getOffset(); final String replacement = sb.toString(); ps.getDoc().replace(start, ps.getSelLength(), replacement); return new Tuple<Integer, Integer>(start, replacement.length()); }
@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(); } }
public String toString() { FastStringBuffer buf = new FastStringBuffer(); buf.append( FullRepIterable.getLastPart( super .toString())); // something as org.eclipse.ui.internal.WorkingSet@2813 will become // WorkingSet@2813 buf.append(" ("); buf.append(this.getActualObject().toString()); buf.append(")"); return buf.toString(); }
private static String getQuotedString(char quote, String string) { // Implemented using SimpleRunner.getArgumentsAsStr as a starting point if (string == null || string.length() == 0) return "" + quote + quote; FastStringBuffer buf = new FastStringBuffer(); buf.append(quote); char[] characters = string.toCharArray(); for (int j = 0; j < characters.length; j++) { char character = characters[j]; if (character == quote) { buf.append('\\'); } else if (character == '\\') { buf.append('\\'); } buf.append(character); } buf.append(quote); return buf.toString(); }
/** * We just want to trim whitespaces, not newlines! * * @param locBuf the buffer to be trimmed * @return the same buffer passed as a parameter */ private FastStringBuffer rtrim(FastStringBuffer locBuf) { while (locBuf.length() > 0 && (locBuf.lastChar() == ' ' || locBuf.lastChar() == '\t')) { locBuf.deleteLast(); } return locBuf; }
/** @see org.eclipse.jface.text.rules.IWordDetector#isWordStart(char) */ public boolean isWordStart(char c) { isInHexa = false; buffer.clear(); buffer.append(c); return Character.isDigit(c); }
private void fillNatureCompletionsForConsole( IScriptConsoleViewer viewer, int requestOffset, List<ICompletionProposal> completions, String qual, boolean addAutoImport, int qlen, String lowerQual, IPythonNature nature, boolean getSystem) { AbstractAdditionalInterpreterInfo additionalInfoForProject; if (getSystem) { try { additionalInfoForProject = AdditionalSystemInterpreterInfo.getAdditionalSystemInfo( PydevPlugin.getInterpreterManager(nature), nature.getProjectInterpreter().getExecutableOrJar()); } catch (Exception e) { PydevPlugin.log(e); return; } } else { try { additionalInfoForProject = AdditionalProjectInterpreterInfo.getAdditionalInfoForProject(nature); } catch (Exception e) { PydevPlugin.log(e); return; } } List<IInfo> tokensStartingWith = additionalInfoForProject.getTokensStartingWith( qual, AbstractAdditionalInterpreterInfo.TOP_LEVEL); FastStringBuffer realImportRep = new FastStringBuffer(); FastStringBuffer displayString = new FastStringBuffer(); FastStringBuffer tempBuf = new FastStringBuffer(); for (IInfo info : tokensStartingWith) { // there always must be a declaringModuleName String declaringModuleName = info.getDeclaringModuleName(); boolean hasInit = false; if (declaringModuleName.endsWith(".__init__")) { declaringModuleName = declaringModuleName.substring( 0, declaringModuleName.length() - 9); // remove the .__init__ hasInit = true; } String rep = info.getName(); String lowerRep = rep.toLowerCase(); if (!lowerRep.startsWith(lowerQual)) { continue; } if (addAutoImport) { realImportRep.clear(); realImportRep.append("from "); realImportRep.append( AutoImportsPreferencesPage.removeImportsStartingWithUnderIfNeeded( declaringModuleName, tempBuf)); realImportRep.append(" import "); realImportRep.append(rep); } displayString.clear(); displayString.append(rep); displayString.append(" - "); displayString.append(declaringModuleName); if (hasInit) { displayString.append(".__init__"); } PyConsoleCompletion proposal = new PyConsoleCompletion( rep, requestOffset - qlen, qlen, realImportRep.length(), AnalysisPlugin.getImageForAutoImportTypeInfo(info), displayString.toString(), (IContextInformation) null, "", lowerRep.equals(lowerQual) ? IPyCompletionProposal.PRIORITY_LOCALS_1 : IPyCompletionProposal.PRIORITY_GLOBALS, realImportRep.toString(), viewer); completions.add(proposal); } }
/** * 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(); 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 comments or multiline comments... i = parsingUtils.eatLiterals(buf, i); break; case '#': i = parsingUtils.eatComments(buf, i); break; case ',': i = formatForComma(std, cs, buf, i); 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 FastStringBuffer localBufToCheckWildImport = new FastStringBuffer(); while (Character.isJavaIdentifierPart(localC)) { localBufToCheckWildImport.append(localC); j--; if (j < 0) { break; // break while } localC = buf.charAt(j); } if (!localBufToCheckWildImport.reverse().toString().equals("import")) { isOperator = true; } } if (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 FastStringBuffer localBufToCheckNumber = new FastStringBuffer(); 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 == '.') { localBufToCheckNumber.append(localC); } else { break; // break for } } boolean isExponential = true; String partialNumber = localBufToCheckNumber.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(); } rightTrimIfNeeded(std, buf); } buf.append(c); } lastChar = c; } if (parensLevel == 0) { rightTrimIfNeeded(std, buf); if (std.addNewLineAtEndOfFile) { char tempC; if (buf.length() == 0 || ((tempC = buf.lastChar()) != '\r' && tempC != '\n')) { buf.append(delimiter); } } } return buf.toString(); }
/** * Change the pythonpath (used for both: system and project) * * @param project: may be null * @param defaultSelectedInterpreter: may be null */ public void changePythonPath( String pythonpath, final IProject project, IProgressMonitor monitor) { pythonPathHelper.setPythonPath(pythonpath); ModulesFoundStructure modulesFound = pythonPathHelper.getModulesFoundStructure(monitor); // now, on to actually filling the module keys ModulesKeyTreeMap<ModulesKey, ModulesKey> keys = new ModulesKeyTreeMap<ModulesKey, ModulesKey>(); 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(); File f = entry.getKey(); String m = entry.getValue(); if (j % 15 == 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); } if (m != null) { // we don't load them at this time. 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())) { // 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); } } } } for (ZipContents zipContents : modulesFound.zipContents) { if (monitor.isCanceled()) { break; } for (String filePathInZip : zipContents.foundFileZipPaths) { String modName = StringUtils.stripExtension(filePathInZip).replace('/', '.'); if (DEBUG_ZIP) { System.out.println("Found in zip:" + modName); } ModulesKey k = new ModulesKeyForZip(modName, zipContents.zipFile, filePathInZip, true); keys.put(k, k); if (zipContents.zipContentsType == ZipContents.ZIP_CONTENTS_TYPE_JAR) { // folder modules are only created for jars (because for python files, the __init__.py is // required). for (String s : new FullRepIterable( FullRepIterable.getWithoutLastPart( modName))) { // the one without the last part was already added k = new ModulesKeyForZip(s, zipContents.zipFile, s.replace('.', '/'), false); keys.put(k, k); } } } } onChangePythonpath(keys); // assign to instance variable this.setModules(keys); }
private Collection<CtxInsensitiveImportComplProposal> getThem( CompletionRequest request, ICompletionState state, boolean addAutoImport) throws MisconfigurationException { ArrayList<CtxInsensitiveImportComplProposal> completions = new ArrayList<CtxInsensitiveImportComplProposal>(); if (request.isInCalltip) { return completions; } HashSet<String> importedNames = getImportedNames(state); String qual = request.qualifier; if (qual.length() >= CodeCompletionPreferencesPage .getCharsForContextInsensitiveGlobalTokensCompletion()) { // at least n characters // required... String lowerQual = qual.toLowerCase(); String initialModule = request.resolveModule(); List<IInfo> tokensStartingWith = AdditionalProjectInterpreterInfo.getTokensStartingWith( qual, request.nature, AbstractAdditionalInterpreterInfo.TOP_LEVEL); FastStringBuffer realImportRep = new FastStringBuffer(); FastStringBuffer displayString = new FastStringBuffer(); FastStringBuffer tempBuf = new FastStringBuffer(); for (IInfo info : tokensStartingWith) { // there always must be a declaringModuleName String declaringModuleName = info.getDeclaringModuleName(); if (initialModule != null && declaringModuleName != null) { if (initialModule.equals(declaringModuleName)) { continue; } } boolean hasInit = false; if (declaringModuleName.endsWith(".__init__")) { declaringModuleName = declaringModuleName.substring( 0, declaringModuleName.length() - 9); // remove the .__init__ hasInit = true; } String rep = info.getName(); String lowerRep = rep.toLowerCase(); if (!lowerRep.startsWith(lowerQual) || importedNames.contains(rep)) { continue; } if (addAutoImport) { realImportRep.clear(); realImportRep.append("from "); realImportRep.append( AutoImportsPreferencesPage.removeImportsStartingWithUnderIfNeeded( declaringModuleName, tempBuf)); realImportRep.append(" import "); realImportRep.append(rep); } displayString.clear(); displayString.append(rep); displayString.append(" - "); displayString.append(declaringModuleName); if (hasInit) { displayString.append(".__init__"); } CtxInsensitiveImportComplProposal proposal = new CtxInsensitiveImportComplProposal( rep, request.documentOffset - request.qlen, request.qlen, realImportRep.length(), AnalysisPlugin.getImageForAutoImportTypeInfo(info), displayString.toString(), (IContextInformation) null, "", lowerRep.equals(lowerQual) ? IPyCompletionProposal.PRIORITY_LOCALS_1 : IPyCompletionProposal.PRIORITY_GLOBALS, realImportRep.toString()); completions.add(proposal); } } return completions; }
/** * 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_STATEMENT_TOKENS.contains(trimmedLastWord); if (!isUnary) { for (char itChar : buf.reverseIterator()) { if (itChar == ' ' || itChar == '\t') { continue; } if (itChar == '=' || itChar == ',') { isUnary = true; } switch (itChar) { 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; }
@Override public String toString() { FastStringBuffer buffer = new FastStringBuffer(); buffer.append("CompletionRequest["); buffer.append(" editorFile:"); buffer.appendObject(editorFile); buffer.append(" activationToken:"); buffer.append(activationToken); buffer.append(" qualifier:"); buffer.append(qualifier); buffer.append(" isInCalltip:"); buffer.append(isInCalltip); buffer.append(" alreadyHasParams:"); buffer.append(alreadyHasParams); buffer.append("]"); return buffer.toString(); }
/** * 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) + 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; } }
/** * Returns the directories and python files in a list. * * @param addSubFolders indicates if sub-folders should be added * @param canonicalFolders used to know if we entered a loop in the listing (with symlinks) * @return An object with the results of making that listing. */ private static PyFileListing getPyFilesBelow( PyFileListing result, File file, FileFilter filter, IProgressMonitor monitor, boolean addSubFolders, int level, boolean checkHasInit, String currModuleRep, Set<File> canonicalFolders) { if (monitor == null) { monitor = new NullProgressMonitor(); } if (file != null && file.exists()) { // only check files that actually exist if (file.isDirectory()) { if (level != 0) { FastStringBuffer newModuleRep = new FastStringBuffer(currModuleRep, 128); if (newModuleRep.length() != 0) { newModuleRep.append("."); } newModuleRep.append(file.getName()); currModuleRep = newModuleRep.toString(); } // check if it is a symlink loop try { File canonicalizedDir = file.getCanonicalFile(); if (!canonicalizedDir.equals(file)) { if (canonicalFolders.contains(canonicalizedDir)) { return result; } } canonicalFolders.add(canonicalizedDir); } catch (IOException e) { PydevPlugin.log(e); } File[] files = null; if (filter != null) { files = file.listFiles(filter); } else { files = file.listFiles(); } boolean hasInit = false; List<File> foldersLater = new LinkedList<File>(); for (File file2 : files) { if (monitor.isCanceled()) { break; } if (file2.isFile()) { result.addPyFileInfo(new PyFileInfo(file2, currModuleRep)); monitor.worked(1); monitor.setTaskName("Found:" + file2.toString()); if (checkHasInit && hasInit == false) { // only check if it has __init__ if really needed if (PythonPathHelper.isValidInitFile(file2.getName())) { hasInit = true; } } } else { foldersLater.add(file2); } } if (!checkHasInit || hasInit || level == 0) { result.foldersFound.add(file); for (File folder : foldersLater) { if (monitor.isCanceled()) { break; } if (folder.isDirectory() && addSubFolders) { getPyFilesBelow( result, folder, filter, monitor, addSubFolders, level + 1, checkHasInit, currModuleRep, canonicalFolders); monitor.worked(1); } } } } else if (file.isFile()) { result.addPyFileInfo(new PyFileInfo(file, currModuleRep)); } else { throw new RuntimeException("Not dir nor file... what is it?"); } } return result; }
/** * @param root the zip file to analyze * @param monitor the monitor, to keep track of what is happening * @return a list with the name of the found modules in the jar */ protected static ModulesFoundStructure.ZipContents getFromZip( File root, IProgressMonitor monitor) { String fileName = root.getName(); if (root.isFile() && FileTypesPreferencesPage.isValidZipFile( fileName)) { // ok, it may be a jar file, so let's get its contents and get the // available modules // the major difference from handling jars from regular python files is that we don't have to // check for __init__.py files ModulesFoundStructure.ZipContents zipContents = new ModulesFoundStructure.ZipContents(root); // by default it's a zip (for python) -- may change if a .class is found. zipContents.zipContentsType = ZipContents.ZIP_CONTENTS_TYPE_PY_ZIP; try { String zipFileName = root.getName(); ZipFile zipFile = new ZipFile(root); try { Enumeration<? extends ZipEntry> entries = zipFile.entries(); int i = 0; FastStringBuffer buffer = new FastStringBuffer(); // ok, now that we have the zip entries, let's map them to modules while (entries.hasMoreElements()) { ZipEntry entry = entries.nextElement(); String name = entry.getName(); if (!entry.isDirectory()) { if (isValidFileMod(name) || name.endsWith(".class")) { if (name.endsWith(".class")) { zipContents.zipContentsType = ZipContents.ZIP_CONTENTS_TYPE_JAR; } // it is a valid python file if (i % 15 == 0) { if (monitor.isCanceled()) { return null; } buffer.clear(); monitor.setTaskName( buffer .append("Found in ") .append(zipFileName) .append(" module ") .append(name) .toString()); monitor.worked(1); } if (isValidInitFile(name)) { zipContents.pyInitFilesLowerWithoutExtension.add( StringUtils.stripExtension(name).toLowerCase()); } zipContents.pyFilesLowerToRegular.put(name.toLowerCase(), name); } } else { // !isDirectory zipContents.pyfoldersLower.add(name.toLowerCase()); } i++; } } finally { zipFile.close(); } // now, on to actually filling the structure if we have a zip file (just add the ones that // are actually under // the pythonpath) zipContents.consolidatePythonpathInfo(monitor); return zipContents; } catch (Exception e) { // that's ok, it is probably not a zip file after all... PydevPlugin.log(e); } } return null; }