コード例 #1
0
  private void visitFunc(IASTFunctionDefinition declaration) throws BadLocationException {
    IASTStatement body = declaration.getBody();
    if (!(body instanceof IASTCompoundStatement)) return;

    // starting a function empties the stack... (which should already be empty on good flow)
    _scopeStack.clear();

    IASTFileLocation location = body.getFileLocation();
    int endLoc = location.getNodeOffset() + location.getNodeLength() - 1;

    IASTFunctionDeclarator declerator = declaration.getDeclarator();
    int startLoc = declerator.getFileLocation().getNodeOffset();

    StringBuffer hint = new StringBuffer();
    hint.append(declerator.getName().getRawSignature());
    /* TODO: specific params: exclude function parameters (show only the name) */
    hint.append("( "); // $NON-NLS-1$
    IASTNode[] decChildren = declerator.getChildren();
    boolean firstParam = true;
    for (int i = 0; i < decChildren.length; i++) {
      IASTNode node = decChildren[i];
      if (node instanceof IASTParameterDeclaration) {
        IASTParameterDeclaration param = (IASTParameterDeclaration) node;
        if (firstParam) firstParam = false;
        else hint.append(", "); // $NON-NLS-1$
        hint.append(param.getDeclarator().getName());
      }
    }
    hint.append(" )"); // $NON-NLS-1$

    _container.add(new Hint("function", startLoc, endLoc, hint.toString())); // $NON-NLS-1$
  }
コード例 #2
0
ファイル: LookupData.java プロジェクト: Traveller7/cdt
  public boolean forFriendship() {
    if (astName == null) return false;
    IASTNode node = astName.getParent();
    while (node instanceof IASTName) node = node.getParent();

    IASTDeclaration decl = null;
    IASTDeclarator dtor = null;
    if (node instanceof ICPPASTDeclSpecifier && node.getParent() instanceof IASTDeclaration) {
      decl = (IASTDeclaration) node.getParent();
    } else if (node instanceof IASTDeclarator) {
      dtor = (IASTDeclarator) node;
      while (dtor.getParent() instanceof IASTDeclarator) dtor = (IASTDeclarator) dtor.getParent();
      if (!(dtor.getParent() instanceof IASTDeclaration)) return false;
      decl = (IASTDeclaration) dtor.getParent();
    } else {
      return false;
    }
    if (decl instanceof IASTSimpleDeclaration) {
      IASTSimpleDeclaration simple = (IASTSimpleDeclaration) decl;
      if (!((ICPPASTDeclSpecifier) simple.getDeclSpecifier()).isFriend()) return false;
      if (dtor != null) return true;
      return simple.getDeclarators().length == 0;
    } else if (decl instanceof IASTFunctionDefinition) {
      IASTFunctionDefinition fnDef = (IASTFunctionDefinition) decl;
      if (!((ICPPASTDeclSpecifier) fnDef.getDeclSpecifier()).isFriend()) return false;
      return (dtor != null);
    }
    return false;
  }
コード例 #3
0
  @Override
  protected void collectModifications(IProgressMonitor pm, ModificationCollector collector)
      throws CoreException, OperationCanceledException {
    List<IASTNode> getterAndSetters = new ArrayList<IASTNode>();
    List<IASTFunctionDefinition> definitions = new ArrayList<IASTFunctionDefinition>();
    for (GetterSetterInsertEditProvider currentProvider : context.selectedFunctions) {
      if (context.isDefinitionSeparate()) {
        getterAndSetters.add(currentProvider.getFunctionDeclaration());
        IASTFunctionDefinition functionDefinition = currentProvider.getFunctionDefinition(true);
        // Standalone definitions in a header file have to be declared inline.
        if (definitionInsertLocation.getTranslationUnit().isHeaderUnit()) {
          functionDefinition.getDeclSpecifier().setInline(true);
        }
        definitions.add(functionDefinition);
      } else {
        getterAndSetters.add(currentProvider.getFunctionDefinition(false));
      }
    }
    if (context.isDefinitionSeparate()) {
      addDefinition(collector, definitions, pm);
    }
    ICPPASTCompositeTypeSpecifier classDefinition =
        (ICPPASTCompositeTypeSpecifier)
            context.existingFields.get(context.existingFields.size() - 1).getParent();

    AddDeclarationNodeToClassChange.createChange(
        classDefinition, VisibilityEnum.v_public, getterAndSetters, false, collector);
  }
コード例 #4
0
ファイル: FaultToleranceTests.java プロジェクト: zhaog/cdt
  // _MYMACRO_ myType foo();
  // _MYMACRO_ myType foo() {}
  // extern void foo2() _MYMACRO_;
  public void testUndefinedMacrosInFunctionDeclarations_Bug234085() throws Exception {
    final String comment = getAboveComment();
    for (ParserLanguage lang : ParserLanguage.values()) {
      IASTTranslationUnit tu = parse(comment, lang, false, false);
      IASTProblemDeclaration pd = getDeclaration(tu, 0);
      assertEquals("_MYMACRO_", pd.getRawSignature());
      IASTSimpleDeclaration sdecl = getDeclaration(tu, 1);
      assertEquals("myType foo();", sdecl.getRawSignature());

      pd = getDeclaration(tu, 2);
      assertEquals("_MYMACRO_", pd.getRawSignature());
      IASTFunctionDefinition fdef = getDeclaration(tu, 3);
      assertEquals("myType foo() {}", fdef.getRawSignature());

      sdecl = getDeclaration(tu, 4);
      assertEquals("extern void foo2()", sdecl.getRawSignature());
      pd = getDeclaration(tu, 5); // the missing semicolon

      if (lang == ParserLanguage.CPP) {
        pd = getDeclaration(tu, 6);
        assertEquals("_MYMACRO_;", pd.getRawSignature());
      } else {
        sdecl = getDeclaration(tu, 6);
        assertEquals("_MYMACRO_;", sdecl.getRawSignature());
      }
    }
  }
コード例 #5
0
 public void testBug94933() throws Exception {
   StringBuffer buffer = new StringBuffer("#define API extern\n"); // $NON-NLS-1$
   buffer.append("#define MYAPI API\n"); // $NON-NLS-1$
   buffer.append("MYAPI void func() {}"); // $NON-NLS-1$
   String code = buffer.toString();
   for (ParserLanguage language : languages) {
     IASTTranslationUnit tu = parse(code, language);
     IASTFunctionDefinition f = (IASTFunctionDefinition) tu.getDeclarations()[0];
     assertNotNull(f.getFileLocation());
   }
 }
コード例 #6
0
 @Override
 public void modifyAST(IIndex index, IMarker marker) {
   CompositeChange c = new CompositeChange(Messages.QuickFixCreateParameter_0);
   try {
     ITranslationUnit baseTU = getTranslationUnitViaEditor(marker);
     IASTTranslationUnit baseAST = baseTU.getAST(index, ITranslationUnit.AST_SKIP_INDEXED_HEADERS);
     IASTName astName = getASTNameFromMarker(marker, baseAST);
     if (astName == null) {
       return;
     }
     IASTDeclaration declaration =
         CxxAstUtils.createDeclaration(astName, baseAST.getASTNodeFactory(), index);
     // We'll need a FunctionParameterDeclaration later
     final IASTDeclSpecifier finalDeclSpec = (IASTDeclSpecifier) declaration.getChildren()[0];
     final IASTDeclarator finalDeclarator = (IASTDeclarator) declaration.getChildren()[1];
     IASTFunctionDefinition function = CxxAstUtils.getEnclosingFunction(astName);
     if (function == null) {
       return;
     }
     // Find the function declarations
     NameFinderVisitor nameFinderVisitor = new NameFinderVisitor();
     function.accept(nameFinderVisitor);
     IASTName funcName = nameFinderVisitor.name;
     IBinding binding = funcName.resolveBinding();
     IIndexName[] declarations = index.findNames(binding, IIndex.FIND_DECLARATIONS_DEFINITIONS);
     if (declarations.length == 0) {
       return;
     }
     HashMap<ITranslationUnit, IASTTranslationUnit> cachedASTs =
         new HashMap<ITranslationUnit, IASTTranslationUnit>();
     HashMap<ITranslationUnit, ASTRewrite> cachedRewrites =
         new HashMap<ITranslationUnit, ASTRewrite>();
     for (IIndexName iname : declarations) {
       ITranslationUnit declTU = CxxAstUtils.getTranslationUnitFromIndexName(iname);
       if (declTU == null) {
         continue;
       }
       ASTRewrite rewrite;
       IASTTranslationUnit declAST;
       if (!cachedASTs.containsKey(declTU)) {
         declAST = declTU.getAST(index, ITranslationUnit.AST_SKIP_INDEXED_HEADERS);
         rewrite = ASTRewrite.create(declAST);
         cachedASTs.put(declTU, declAST);
         cachedRewrites.put(declTU, rewrite);
       } else {
         declAST = cachedASTs.get(declTU);
         rewrite = cachedRewrites.get(declTU);
       }
       IASTFileLocation fileLocation = iname.getFileLocation();
       IASTName declName =
           declAST
               .getNodeSelector(null)
               .findEnclosingName(fileLocation.getNodeOffset(), fileLocation.getNodeLength());
       if (declName == null) {
         continue;
       }
       INodeFactory factory = declAST.getASTNodeFactory();
       IASTFunctionDeclarator functionDecl;
       {
         IASTNode n = declName;
         while (n instanceof IASTName) {
           n = n.getParent();
         }
         functionDecl = (IASTFunctionDeclarator) n;
       }
       IASTParameterDeclaration newParam =
           factory.newParameterDeclaration(finalDeclSpec, finalDeclarator);
       rewrite.insertBefore(functionDecl, null, newParam, null);
     }
     for (ASTRewrite rewrite : cachedRewrites.values()) {
       c.add(rewrite.rewriteAST());
     }
     c.perform(new NullProgressMonitor());
   } catch (CoreException e) {
     CheckersUiActivator.log(e);
   }
 }
コード例 #7
0
 /*
  * @see org.eclipse.cdt.core.dom.ast.ASTVisitor#visit(org.eclipse.cdt.core.dom.ast.IASTDeclaration)
  */
 @Override
 public int visit(IASTDeclaration node) {
   boolean isTemplateDecl = isTemplateDecl(node);
   final int startOffset =
       isTemplateDecl ? getStartOffset(node.getParent()) : getStartOffset(node);
   final int endOffset = getEndOffset(node);
   if (node instanceof IASTFunctionDefinition) {
     IASTFunctionDefinition functionDef = (IASTFunctionDefinition) node;
     final int nodeType;
     if (inClassBody()) {
       nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_METHOD : ICElement.C_METHOD;
     } else {
       nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_FUNCTION : ICElement.C_FUNCTION;
     }
     push(nodeType, getDeclaratorName(functionDef.getDeclarator()), startOffset);
     pop(endOffset);
     return PROCESS_SKIP;
   } else if (node instanceof IASTSimpleDeclaration) {
     IASTSimpleDeclaration simpleDecl = (IASTSimpleDeclaration) node;
     IASTDeclSpecifier declSpec = simpleDecl.getDeclSpecifier();
     if (declSpec instanceof ICPPASTCompositeTypeSpecifier) {
       ICPPASTCompositeTypeSpecifier compositeTypeSpec = (ICPPASTCompositeTypeSpecifier) declSpec;
       final String nodeName = getTypeName(compositeTypeSpec);
       final int nodeType;
       switch (compositeTypeSpec.getKey()) {
         case IASTCompositeTypeSpecifier.k_struct:
           nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_STRUCT : ICElement.C_STRUCT;
           break;
         case IASTCompositeTypeSpecifier.k_union:
           nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_UNION : ICElement.C_UNION;
           break;
         case ICPPASTCompositeTypeSpecifier.k_class:
           nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_CLASS : ICElement.C_CLASS;
           break;
         default:
           assert false : "Unexpected composite type specifier"; // $NON-NLS-1$
           return PROCESS_CONTINUE;
       }
       push(nodeType, nodeName, startOffset);
     } else if (declSpec instanceof IASTEnumerationSpecifier) {
       IASTEnumerationSpecifier enumSpecifier = (IASTEnumerationSpecifier) declSpec;
       push(ICElement.C_ENUMERATION, getEnumerationName(enumSpecifier), startOffset);
     } else {
       IASTDeclarator[] declarators = simpleDecl.getDeclarators();
       for (int i = 0; i < declarators.length; i++) {
         IASTDeclarator declarator = declarators[i];
         int declStartOffset = declarators.length == 1 ? startOffset : getStartOffset(declarator);
         int declEndOffset = declarators.length == 1 ? endOffset : getEndOffset(declarator);
         final String nodeName = getDeclaratorName(declarator);
         if (declSpec.getStorageClass() == IASTDeclSpecifier.sc_typedef) {
           push(ICElement.C_TYPEDEF, nodeName, declStartOffset);
           pop(declEndOffset);
         } else if (declarator instanceof IASTFunctionDeclarator
             && !hasNestedPointerOperators(declarator)) {
           final int nodeType;
           if (inClassBody()) {
             nodeType =
                 isTemplateDecl
                     ? ICElement.C_TEMPLATE_METHOD_DECLARATION
                     : ICElement.C_METHOD_DECLARATION;
           } else {
             nodeType =
                 isTemplateDecl
                     ? ICElement.C_TEMPLATE_FUNCTION_DECLARATION
                     : ICElement.C_FUNCTION_DECLARATION;
           }
           push(nodeType, nodeName, declStartOffset);
           pop(declEndOffset);
         } else if (declarator != null) {
           final int nodeType;
           if (inClassBody()) {
             nodeType = ICElement.C_FIELD;
           } else {
             if (declSpec.getStorageClass() == IASTDeclSpecifier.sc_extern) {
               nodeType = ICElement.C_VARIABLE_DECLARATION;
             } else {
               nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_VARIABLE : ICElement.C_VARIABLE;
             }
           }
           push(nodeType, nodeName, declStartOffset);
           pop(declEndOffset);
         }
       }
     }
   } else if (node instanceof IASTASMDeclaration) {
     // ignored
   } else if (node instanceof ICPPASTVisibilityLabel) {
     // ignored
   } else if (node instanceof ICPPASTNamespaceDefinition) {
     // handled below
   } else if (node instanceof ICPPASTNamespaceAlias) {
     // ignored
   } else if (node instanceof ICPPASTUsingDeclaration) {
     ICPPASTUsingDeclaration usingDecl = (ICPPASTUsingDeclaration) node;
     push(ICElement.C_USING, ASTStringUtil.getQualifiedName(usingDecl.getName()), startOffset);
     pop(endOffset);
   } else if (node instanceof ICPPASTUsingDirective) {
     ICPPASTUsingDirective usingDirective = (ICPPASTUsingDirective) node;
     push(
         ICElement.C_USING,
         ASTStringUtil.getQualifiedName(usingDirective.getQualifiedName()),
         startOffset);
     pop(endOffset);
   } else if (node instanceof ICPPASTLinkageSpecification) {
     // declarations get flattened
   } else if (node instanceof ICPPASTTemplateDeclaration) {
     // handled at child declaration level
   } else if (node instanceof ICPPASTTemplateSpecialization) {
     // ignored
   } else if (node instanceof ICPPASTExplicitTemplateInstantiation) {
     // ignored
   } else if (node instanceof IASTProblemDeclaration) {
     // ignored
   }
   return super.visit(node);
 }