示例#1
0
 private List<FoldingEntry> getMarks(Document doc, int grammarVersion) {
   ParseOutput r = PyParser.reparseDocument(new PyParser.ParserInfo(doc, grammarVersion, null));
   List<FoldingEntry> marks = CodeFoldingSetter.getMarks(doc, (SimpleNode) r.ast, true);
   if (DEBUG) {
     for (FoldingEntry entry : marks) {
       System.out.println(entry);
     }
   }
   return marks;
 }
示例#2
0
  /**
   * @param request this is the request for the completion
   * @param theList OUT - returned completions are added here. (IToken instances)
   * @param getOnlySupers whether we should only get things from super classes (in this case, we
   *     won't get things from the current class)
   * @param checkIfInCorrectScope if true, we'll first check if we're in a scope that actually has a
   *     method with 'self' or 'cls'
   * @return true if we actually tried to get the completions for self or cls.
   * @throws MisconfigurationException
   */
  @SuppressWarnings("unchecked")
  public static boolean getSelfOrClsCompletions(
      CompletionRequest request,
      List theList,
      ICompletionState state,
      boolean getOnlySupers,
      boolean checkIfInCorrectScope,
      String lookForRep)
      throws MisconfigurationException {

    SimpleNode s =
        PyParser.reparseDocument(
                new PyParser.ParserInfo(request.doc, true, request.nature, state.getLine()))
            .o1;
    if (s != null) {
      FindScopeVisitor visitor = new FindScopeVisitor(state.getLine(), 0);
      try {
        s.accept(visitor);
        if (checkIfInCorrectScope) {
          boolean scopeCorrect = false;

          FastStack<SimpleNode> scopeStack = visitor.scope.getScopeStack();
          for (Iterator<SimpleNode> it = scopeStack.topDownIterator();
              scopeCorrect == false && it.hasNext(); ) {
            SimpleNode node = it.next();
            if (node instanceof FunctionDef) {
              FunctionDef funcDef = (FunctionDef) node;
              if (funcDef.args != null
                  && funcDef.args.args != null
                  && funcDef.args.args.length > 0) {
                // ok, we have some arg, let's check for self or cls
                String rep = NodeUtils.getRepresentationString(funcDef.args.args[0]);
                if (rep != null && (rep.equals("self") || rep.equals("cls"))) {
                  scopeCorrect = true;
                }
              }
            }
          }
          if (!scopeCorrect) {
            return false;
          }
        }
        if (lookForRep.equals("self")) {
          state.setLookingFor(ICompletionState.LOOKING_FOR_INSTANCED_VARIABLE);
        } else {
          state.setLookingFor(ICompletionState.LOOKING_FOR_CLASSMETHOD_VARIABLE);
        }
        getSelfOrClsCompletions(visitor.scope, request, theList, state, getOnlySupers);
      } catch (Exception e1) {
        PydevPlugin.log(e1);
      }
      return true;
    }
    return false;
  }
示例#3
0
  /**
   * This function creates the module given that you have a document (that will be parsed)
   *
   * @throws MisconfigurationException
   */
  public static SourceModule createModuleFromDoc(
      String name,
      File f,
      IDocument doc,
      IPythonNature nature,
      boolean checkForPath,
      IGrammarVersionProvider grammarVersionProvider)
      throws MisconfigurationException {
    // for doc, we are only interested in python files.

    if (f != null) {
      if (!checkForPath || PythonPathHelper.isValidSourceFile(f.getName())) {
        ParseOutput obj =
            PyParser.reparseDocument(new PyParser.ParserInfo(doc, grammarVersionProvider, name, f));
        return new SourceModule(name, f, (SimpleNode) obj.ast, obj.error, nature);
      }
    } else {
      ParseOutput obj =
          PyParser.reparseDocument(new PyParser.ParserInfo(doc, grammarVersionProvider, name, f));
      return new SourceModule(name, f, (SimpleNode) obj.ast, obj.error, nature);
    }
    return null;
  }
示例#4
0
  public static Module getRootNode(IDocument doc) throws ParseException {
    Tuple<SimpleNode, Throwable> objects =
        PyParser.reparseDocument(
            new PyParser.ParserInfo(doc, false, IPythonNature.LATEST_GRAMMAR_VERSION));
    Throwable exception = objects.o2;

    if (exception != null) {
      /* We try to get rid of the 'Throwable' exception, if possible */
      if (exception instanceof ParseException) {
        throw (ParseException) exception;
      } else if (exception instanceof TokenMgrError) {
        /* Error from Lexer */
        throw new ParseException(exception.toString());
      } else {
        throw new RuntimeException(exception);
      }
    }

    if (objects.o2 != null) throw new RuntimeException(objects.o2);
    return (Module) objects.o1;
  }