Java IASTExpression类代码示例

import org.eclipse.cdt.core.dom.ast.IASTExpression; //导入依赖的package包/类
public IValue parseExpression(IString expression, IEvaluatorContext ctx) throws CoreException, IOException {
	setIEvaluatorContext(ctx);
	if (!expression.getValue().endsWith(";"))
		expression.concat(vf.string(";"));
	String expr = "void main() {\n\t" + expression.getValue() + "\n}";
	FileContent fc = FileContent.create("", expr.toCharArray());
	Map<String, String> macroDefinitions = new HashMap<String, String>();
	String[] includeSearchPaths = new String[0];
	IScannerInfo si = new ScannerInfo(macroDefinitions, includeSearchPaths);
	IncludeFileContentProvider ifcp = IncludeFileContentProvider.getEmptyFilesProvider();
	IIndex idx = null;
	int options = ILanguage.OPTION_PARSE_INACTIVE_CODE;
	IParserLogService log = new DefaultLogService();
	IASTTranslationUnit tu = GPPLanguage.getDefault().getASTTranslationUnit(fc, si, ifcp, idx, options, log);

	IASTFunctionDefinition main = (IASTFunctionDefinition) tu.getDeclarations()[0];
	IASTCompoundStatement body = (IASTCompoundStatement) main.getBody();
	IASTExpression ex = ((IASTExpressionStatement) body.getStatements()[0]).getExpression();
	ex.accept(this);
	return stack.pop();
}
 

import org.eclipse.cdt.core.dom.ast.IASTExpression; //导入依赖的package包/类
@Override
public int visit(IASTArrayModifier arrayModifier) {
	if (arrayModifier instanceof ICASTArrayModifier)
		throw new RuntimeException("NYI");
	ISourceLocation loc = getSourceLocation(arrayModifier);
	IList attributes = getAttributes(arrayModifier);

	IASTExpression constantExpression = arrayModifier.getConstantExpression();
	if (constantExpression == null)
		stack.push(builder.Expression_arrayModifier(attributes, loc));
	else {
		constantExpression.accept(this);
		stack.push(builder.Expression_arrayModifier(attributes, stack.pop(), loc));
	}
	return PROCESS_ABORT;
}
 

import org.eclipse.cdt.core.dom.ast.IASTExpression; //导入依赖的package包/类
public int visit(IASTExpression expr) {
	if("IASTFunctionCallExpression.FUNCTION_Name - IASTExpression (name) for IASTFunctionCallExpression".equals(expr.getPropertyInParent().getName()))
	{
		funcPosMap.put(expr.getRawSignature(), cnt);
		//System.out.println("expr:"+expr.getRawSignature());
	    functionMap.get(curFunc).getFuncCallList().add(expr.getRawSignature());	
	}
	
	setThings(expr.getPropertyInParent().getName(),"Visiting expr: " + expr.getRawSignature());
	//System.out.println("Visiting expr: " + expr.getPropertyInParent().getName());
	/*if(expr instanceof IASTBinaryExpression)
	{
		System.out.println("!!!!!!11");
		System.out.println("Visiting expr: "+ expr.getPropertyInParent() + expr.getRawSignature());
	}*/
	
	//System.out.println(expr.getPropertyInParent().getName());
	return PROCESS_CONTINUE;
}
 

import org.eclipse.cdt.core.dom.ast.IASTExpression; //导入依赖的package包/类
@Override
public int visit(IASTExpression node) {
	if (node instanceof IASTFieldReference) {
		return visit((IASTFieldReference)node);
	}
	else if (node instanceof IASTIdExpression) {
		return visit((IASTIdExpression)node);
	}
	else if (node instanceof ICPPASTNewExpression) {
		return visit((ICPPASTNewExpression)node);
	}
	else if (node instanceof IASTFunctionCallExpression) {
		return visit((IASTFunctionCallExpression)node);
	}
	else if (node instanceof IASTUnaryExpression) {
		return visit((IASTUnaryExpression)node);   // to check whether this is an assignement
	}
	else if (node instanceof IASTBinaryExpression) {
		return visit((IASTBinaryExpression)node);   // to check whether this is an assignement
	}
	else if (node instanceof IASTLiteralExpression) {
		return visit((IASTLiteralExpression)node);
	}
	else if (node instanceof IASTTypeIdExpression) {
		return visit((IASTTypeIdExpression)node);
	}
	else if (node instanceof IASTCastExpression) {
		return visit((IASTCastExpression)node);
	}

	return super.visit(node);
}
 

import org.eclipse.cdt.core.dom.ast.IASTExpression; //导入依赖的package包/类
public IConstructor resolveType(IASTNode node) {
	if (node instanceof IASTExpression)
		return resolveIASTExpression((IASTExpression) node);
	if (node instanceof ICPPASTTemplateDeclaration)
		return resolveICPPASTTemplateDeclaration((ICPPASTTemplateDeclaration) node);
	if (node instanceof ICPPASTTemplateId)
		return resolveICPPASTTemplateId((ICPPASTTemplateId) node);
	return builder.TypeSymbol_any();
}
 

import org.eclipse.cdt.core.dom.ast.IASTExpression; //导入依赖的package包/类
public int visit(IASTExpression expression) {
    // if it�s a function call
    if (expression instanceof IASTFunctionCallExpression) {
        IASTFunctionCallExpression fce = (IASTFunctionCallExpression) expression;
        IASTExpression astExpr = fce.getFunctionNameExpression();
        String fnSig = astExpr.getRawSignature();
        if (isAssertion(fnSig)) {
            ++m_NumberOfAssertions;
        }
    }
    return PROCESS_CONTINUE;
}
 

import org.eclipse.cdt.core.dom.ast.IASTExpression; //导入依赖的package包/类
@Override
public List<CheckResult> check(Object obj) {
    List<CheckResult> checkResults = Lists.newArrayList();

    IASTTranslationUnit translationUnit = (IASTTranslationUnit) obj;
    ASTExpressionsVisitor expressionsVisitor = new ASTExpressionsVisitor();
    translationUnit.accept(expressionsVisitor);

    for (IASTExpression expression: expressionsVisitor.getExpressions()) {
        if (!(expression instanceof IASTFunctionCallExpression))
            continue;
        IASTFunctionCallExpression callExpression = (IASTFunctionCallExpression) expression;
        if (callExpression.getFunctionNameExpression() == null)
            continue;
        if (!overflowFunctions.contains(callExpression.getFunctionNameExpression().toString()))
            continue;
        CheckResult checkResult = new CheckResult(
            ErrorItem.BUFFER_OVERFLOW_FUNCTION,
            ErrorType.RISK,
            translationUnit.getFilePath(),
            expression.getFileLocation().getStartingLineNumber(),
            expression.getFileLocation().getEndingLineNumber()
        );
        checkResults.add(checkResult);

        // log
        Map<String, Object> scopes = Maps.newHashMap();
        scopes.put("checkResult", checkResult);
        scopes.put("functionName", callExpression.getFunctionNameExpression().toString());
        String comments = compileErrorMessage(errorMessage, scopes);
        logger.error(comments);

        checkResult.setComments(comments);
    }

    return checkResults;
}
 

import org.eclipse.cdt.core.dom.ast.IASTExpression; //导入依赖的package包/类
private IConstructor resolveIASTExpression(IASTExpression node) {
	return resolveType(node.getExpressionType());
}
 

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

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