import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
@Override
protected int visit(IASTSimpleDeclaration node) {
	if (declarationIsTypedef(node)) {
		return PROCESS_SKIP;
	}

	returnedEntity = null;
	node.getDeclSpecifier().accept(this);
	referredType = (Type)returnedEntity;

	for (IASTDeclarator declarator : node.getDeclarators()) {
		// gets the entity and sets its simpleDeclaratorReferredType
		declarator.accept(this);
	}
	referredType = null;

	return PROCESS_SKIP;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
@Override
public int visitInternal(IASTDeclarator node) {
	nodeName = node.getName();
	nodeBnd = resolver.getBinding(nodeName);
	StructuralEntity fmx;

	fmx = ensureVariableKind(nodeBnd, nodeName);
	dico.setVisibility(fmx, currentVisibility);

	/* For attributes (ICPPASTDeclarator) the location is that of the parent AST node, i.e. the declaration
	 * For example, in "int a,b;" the declaration starts at "int" whereas there are 2 declarators: a and b
	 */
	dico.addSourceAnchor(fmx, filename, node.getParent().getFileLocation());

	return PROCESS_SKIP;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
@Override
protected int visit(IASTSimpleDeclaration node) {
	if (declarationIsTypedef(node)) {
		// prune typedefs
		return PROCESS_SKIP;
	}

	// K&R style parameter definition
	if (inKnRParams) {
		for (IASTDeclarator decl : node.getDeclarators()) {
			decl.accept(this);
		}
	}

	return PROCESS_CONTINUE;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
@Override
	public int visit(IASTDeclarator node) {
		/* ********************************************************************************************
		 * BE CAREFULL: The order of the tests is important because choices are not mutually exclusive
		 * ex: ICPPASTFunctionDeclarator is a sub-interface of IASTFunctionDeclarator
		 * ******************************************************************************************** */
		if (node instanceof ICPPASTFunctionDeclarator) {
			return this.visit((ICPPASTFunctionDeclarator)node);
		}
		else if (node instanceof IASTStandardFunctionDeclarator) {
			return this.visit((IASTStandardFunctionDeclarator)node);
		}
		else if (node instanceof ICASTKnRFunctionDeclarator) {
			return this.visit((ICASTKnRFunctionDeclarator)node);
		}
		else if (node instanceof IASTFunctionDeclarator) {
			return this.visit((IASTFunctionDeclarator)node);
		}
		else if (node instanceof IASTFieldDeclarator) {  // actually seems to never occur ???
			return this.visit((IASTFieldDeclarator)node);
		}
/* removed to deal with C attributes: IASTDeclarators
  		else if (node instanceof ICPPASTDeclarator) {
			return this.visit((ICPPASTDeclarator)node);
		}
	replaced by the following:
*/	
  		else {
			return this.visitInternal(node);
		}
	}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
/**
 * can be an attribute or K&R style parameter declaration.
 * The inKnRParams is used to tell them apart
 */
@Override
public int visitInternal(IASTDeclarator node) {
	StructuralEntity fmx = null;

	nodeName = node.getName();
	nodeBnd = resolver.getBinding(nodeName);
	if (nodeBnd == null) {
		if (inKnRParams) {
			nodeBnd = resolver.mkStubKey(nodeName, Parameter.class);
		}
		else {
			nodeBnd = resolver.mkStubKey(nodeName, Attribute.class);
		}
	}

	fmx = (StructuralEntity) dico.getEntityByKey(nodeBnd);
	if (fmx != null) {
		fmx.setDeclaredType(referredType);
	}
	else {
	// else forget about it all
	// may happen for example in that case of an argument of a Macro "call", could test that ... ?
	}
	
	return PROCESS_SKIP;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
/**
 * dealing with K&R style parameter declaration
 */
@Override
protected int visitInternal(IASTDeclarator node) {
	if (inKnRParams) {
		nodeName = node.getName();
		nodeBnd = resolver.getBinding(nodeName);
		if (nodeBnd == null) {
			nodeBnd = resolver.mkStubKey(nodeName, Parameter.class);
		}

		privateCreateParameter();
	}

	return PROCESS_SKIP;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
private ISourceLocation resolveDeclarator(IASTDeclarator node) throws URISyntaxException {
	if (node.getName() == null) {
		out("resolveDeclarator has null name. " + node.getClass().getSimpleName() + ": " + node.getRawSignature());
		return FIXME;
	}

	return resolveBinding(node.getName().resolveBinding());
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
@Override
public int visit(IASTDeclarator declarator) {
	if (declarator instanceof IASTArrayDeclarator)
		visit((IASTArrayDeclarator) declarator);
	// else if (declarator instanceof IASTFieldDeclarator)
	// visit((IASTFieldDeclarator) declarator);
	else if (declarator instanceof IASTFunctionDeclarator)
		visit((IASTFunctionDeclarator) declarator);
	else if (declarator instanceof ICPPASTDeclarator)
		visit((ICPPASTDeclarator) declarator);
	else {
		// TODO: add attributes
		List<IConstructor> pointerOperators = new ArrayList<IConstructor>();
		Stream.of(declarator.getPointerOperators()).forEach(it -> {
			it.accept(this);
			pointerOperators.add(stack.pop());
		});
		IConstructor nestedDeclarator = null;
		if (declarator.getNestedDeclarator() != null) {
			declarator.getNestedDeclarator().accept(this);
			nestedDeclarator = stack.pop();
		}
		declarator.getName().accept(this);
		IConstructor name = stack.pop();
		IConstructor initializer = null;
		if (declarator.getInitializer() == null) {

		} else {
			declarator.getInitializer().accept(this);
			initializer = stack.pop();
		}

		throw new RuntimeException("NYI");
	}
	return PROCESS_ABORT;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
public void testExample() {
    IASTTranslationUnit translationUnit = parseCPP(getCommentAbove());
    ASTDeclarationsVisitor declarationsVisitor = new ASTDeclarationsVisitor();
    translationUnit.accept(declarationsVisitor);
    IASTSimpleDeclaration simpleDeclaration = (IASTSimpleDeclaration) declarationsVisitor.getDeclarations().get(0);
    assertTrue(simpleDeclaration.getDeclarators()[0] instanceof IASTDeclarator);
    assertEquals("x", simpleDeclaration.getDeclarators()[0].getName().toString());
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
public void testExample() {
    IASTTranslationUnit translationUnit = parseCPP(getCommentAbove());
    IASTSimpleDeclaration simpleDeclaration = (IASTSimpleDeclaration) translationUnit.getDeclarations()[0];
    IASTDeclarator declarator = simpleDeclaration.getDeclarators()[0];
    IASTName name = declarator.getName();
    assertEquals("x", name.toString());
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
public int visit(IASTDeclarator dtor) {	
//	System.out.println("Visiting dtor: " + dtor.getRawSignature());
//	System.out.println(dtor.getPropertyInParent().getName()+" "+dtor.getName());
          if ("IASTFunctionDefinition.DECLARATOR - IASTFunctionDeclarator for IASTFunctionDefinition".equals(dtor.getPropertyInParent().getName()))
          {
          	curFunc = dtor.getName().toString();
          //	System.out.println(curFunc);
          //	System.out.println(dtor.getName());
          }
          setThings(dtor.getPropertyInParent().getName(),"Visiting dtor: " + dtor.getRawSignature());
	return PROCESS_CONTINUE;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
protected int visitInternal(IASTDeclarator node) {
	return PROCESS_CONTINUE;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
protected int visitInternal(IASTDeclarator node) {
	for (@SuppressWarnings("unused") IASTPointerOperator ptr : node.getPointerOperators()) {
		signature += "*";
	}
	return PROCESS_CONTINUE;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
@Override
protected int visit(IASTSimpleDeclaration node) {
	TypeAlias aliasType = null;
	Type concreteType = null;

	if (declarationIsTypedef(node)) {
		boolean functionPointerTypedef = false;

		if (isFunctionPointerTypedef(node)) {
			concreteType = null;  // TODO create a FunctionPointer special type?
			functionPointerTypedef = true;
		}
		else {
			returnedEntity = null;
			node.getDeclSpecifier().accept(this);
			concreteType = (Type) returnedEntity;
		}

		for (IASTDeclarator declarator : node.getDeclarators()) {
		// this is a typedef, so the declarator(s) should be FAMIXType(s)

			if (functionPointerTypedef) {
				nodeName = declarator.getNestedDeclarator().getName();
			}
			else {
				nodeName = declarator.getName();
			}

			nodeBnd = resolver.getBinding(nodeName);

			if (nodeBnd == null) {
				// create one anyway, assume this is a Type
				nodeBnd = resolver.mkStubKey(nodeName, Type.class);
			}

			aliasType = dico.ensureFamixTypeAlias(nodeBnd, nodeName.toString(), (ContainerEntity)getContext().top());
			aliasType.setIsStub(false);
			aliasType.setParentPackage(currentPackage);
			aliasType.setAliasedType(concreteType);

			declarator.accept(this);
		}
		
		return PROCESS_SKIP;  // typedef already handled
	} 
	// else includes such statement as: "class CAbstractFile;". This needs to be treated (by a reference?)
	return PROCESS_CONTINUE;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
public ISourceLocation resolveBinding2(IASTNameOwner node) {
	try {
		if (node instanceof IASTCompositeTypeSpecifier)
			return resolveCompositeTypeSpecifier((IASTCompositeTypeSpecifier) node);
		if (node instanceof IASTDeclarator)
			return resolveDeclarator((IASTDeclarator) node);
		if (node instanceof IASTElaboratedTypeSpecifier)
			return resolveElaboratedTypeSpecifier((IASTElaboratedTypeSpecifier) node);
		if (node instanceof IASTEnumerationSpecifier)
			return resolveEnumerationSpecifier((IASTEnumerationSpecifier) node);
		if (node instanceof IASTEnumerator)
			return resolveEnumerator((IASTEnumerator) node);
		if (node instanceof IASTFieldReference)
			return resolveFieldReference((IASTFieldReference) node);
		if (node instanceof IASTGotoStatement)
			return resolveGotoStatement((IASTGotoStatement) node);
		if (node instanceof IASTIdExpression)
			return resolveIdExpression((IASTIdExpression) node);
		// Discouraged access
		// if (node instanceof IASTInternalNameOwner)
		// return resolveInternalNameOwner((IASTInternalNameOwner) node);
		if (node instanceof IASTLabelStatement)
			return resolveLabelStatement((IASTLabelStatement) node);
		if (node instanceof IASTNamedTypeSpecifier)
			return resolveNamedTypeSpecifier((IASTNamedTypeSpecifier) node);
		if (node instanceof IASTPreprocessorMacroDefinition)// TODO
			return resolvePreprocessorMacroDefinition((IASTPreprocessorMacroDefinition) node);
		if (node instanceof ICPPASTAliasDeclaration)
			return resolveAliasDeclaration((ICPPASTAliasDeclaration) node);
		if (node instanceof ICPPASTBaseSpecifier)
			return resolveBaseSpecifier((ICPPASTBaseSpecifier) node);
		if (node instanceof ICPPASTCapture)
			return resolveCapture((ICPPASTCapture) node);
		if (node instanceof ICPPASTConstructorChainInitializer)
			return resolveConstructorChainInitializer((ICPPASTConstructorChainInitializer) node);
		if (node instanceof ICPPASTNamespaceAlias)
			return resolveNamespaceAlias((ICPPASTNamespaceAlias) node);
		if (node instanceof ICPPASTNamespaceDefinition)
			return resolveNamespaceDefinition((ICPPASTNamespaceDefinition) node);
		if (node instanceof ICPPASTPointerToMember)// TODO
			return resolvePointerToMember((ICPPASTPointerToMember) node);
		if (node instanceof ICPPASTQualifiedName)
			return resolveQualifiedName((ICPPASTQualifiedName) node);
		if (node instanceof ICPPASTSimpleTypeTemplateParameter)
			return resolveSimpleTypeTemplateParameter((ICPPASTSimpleTypeTemplateParameter) node);
		if (node instanceof ICPPASTTemplatedTypeTemplateParameter)// TODO,
																	// NYI
			return resolveTemplatedTypeTemplateParameter((ICPPASTTemplatedTypeTemplateParameter) node);
		if (node instanceof ICPPASTTemplateId)
			return resolveTemplateId((ICPPASTTemplateId) node);
		// Deprecated // TODO?
		// if (node instanceof ICPPASTTypenameExpression)
		// return resolveTypenameExpression((ICPPASTTypenameExpression)
		// node);
		if (node instanceof ICPPASTUsingDeclaration)
			return resolveUsingDeclaration((ICPPASTUsingDeclaration) node);
		if (node instanceof ICPPASTUsingDirective)
			return resolveUsingDirective((ICPPASTUsingDirective) node);
		// if (node instanceof IGNUASTGotoStatement)
		// return resolveGnuGotoStatement((IGNUASTGotoStatement) node);
	} catch (URISyntaxException e) {
		err("Caught URISyntaxException, return UNKNOWN");
		err(e.getMessage());
	}
	return makeBinding("UNKNOWN4", null, null);
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
public int visit(IASTDeclarator declarator) {
       declarators.add(declarator);
	return PROCESS_CONTINUE;
}
 

import org.eclipse.cdt.core.dom.ast.IASTDeclarator; //导入依赖的package包/类
public int leave(IASTDeclarator dtor) {
	unsetThings();
//	System.out.println("Leaving dtor: " + dtor.getRawSignature());

	return PROCESS_CONTINUE;
}