下面列出了怎么用org.eclipse.jdt.core.dom.NumberLiteral的API类实例代码及写法,或者点击链接到github查看源代码。
public Expression getLongAddress(MethodInvocation mi) {
Expression indexExpr = getLongAddressBase(mi);
NumberLiteral lit = (NumberLiteral)mi.arguments().get(2);
if(offset != Integer.parseInt(lit.getToken()))
throw new IllegalArgumentException("offset != " + lit);
Expression args;
if(offset == 0) args = indexExpr;
else {
InfixExpression add = ast.newInfixExpression();
add.setOperator(InfixExpression.Operator.PLUS);
add.setLeftOperand(indexExpr);
add.setRightOperand(returnInt(offset));
args = add;
}
return args;
}
/**
* {@inheritDoc}
*/
@Override
protected ASTVisitor handleGetCorrectingASTVisitor(final IRegion lineInfo,
final int markerStartOffset) {
return new ASTVisitor() {
@Override
public boolean visit(NumberLiteral node) {
if (containsPosition(node, markerStartOffset)) {
String token = node.getToken();
if (token.endsWith("l")) { //$NON-NLS-1$
token = token.replace('l', 'L');
node.setToken(token);
}
}
return true;
}
};
}
@Override
public ASTVisitor getCorrectingASTVisitor(IRegion lineInfo, int markerStartOffset) {
return new ASTVisitor() {
@Override
public boolean visit(NumberLiteral node) {
if (containsPosition(node, markerStartOffset)) {
String token = node.getToken();
if (token.endsWith("l")) { //$NON-NLS-1$
token = token.replace('l', 'L');
node.setToken(token);
}
}
return true;
}
};
}
private boolean isNotZeroOrOne(NumberLiteral singleNumberLiteral) {
String numberToString = singleNumberLiteral.toString().toLowerCase().replaceAll("_", "");
double literalValue = 0.0;
try {
// hex case
if(numberToString.startsWith("0x")) {
literalValue = (double)(Long.parseLong(numberToString.replaceAll("0x", "").replaceAll("l", ""),16));
// long case
} else if(numberToString.endsWith("l")) {
literalValue = (double)(Long.parseLong(numberToString.replaceAll("l", "")));
// float case
} else if(numberToString.endsWith("f")) {
literalValue = Float.parseFloat(numberToString.replaceAll("f", ""));
}
// double case
else {
literalValue = Double.parseDouble(numberToString);
}
} catch (NumberFormatException ex) {
String logMessage = "Exception while parsing literal number (during Magic Number detection). " + ex.getMessage();
Logger.log(logMessage);
literalValue = 0.0;
}
return literalValue != 0.0 && literalValue != 1.0;
}
@Override
public boolean visit(final ArrayAccess node) {
Expression _index = node.getIndex();
if ((_index instanceof NumberLiteral)) {
node.getArray().accept(this);
this.appendToBuffer(".get(");
node.getIndex().accept(this);
this.appendToBuffer(")");
} else {
final String arrayname = this.computeArrayName(node);
StringConcatenation _builder = new StringConcatenation();
_builder.append("{val _rdIndx_");
_builder.append(arrayname);
_builder.append("=");
this.appendToBuffer(_builder.toString());
node.getIndex().accept(this);
this.appendSpaceToBuffer();
node.getArray().accept(this);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append(".get(_rdIndx_");
_builder_1.append(arrayname);
_builder_1.append(")}");
this.appendToBuffer(_builder_1.toString());
}
return false;
}
protected boolean isTypeHolder(Object o) {
if(o.getClass().equals(MethodInvocation.class) || o.getClass().equals(SuperMethodInvocation.class)
|| o.getClass().equals(NumberLiteral.class) || o.getClass().equals(StringLiteral.class)
|| o.getClass().equals(CharacterLiteral.class) || o.getClass().equals(BooleanLiteral.class)
|| o.getClass().equals(TypeLiteral.class) || o.getClass().equals(NullLiteral.class)
|| o.getClass().equals(ArrayCreation.class)
|| o.getClass().equals(ClassInstanceCreation.class)
|| o.getClass().equals(ArrayAccess.class) || o.getClass().equals(FieldAccess.class)
|| o.getClass().equals(SuperFieldAccess.class) || o.getClass().equals(ParenthesizedExpression.class)
|| o.getClass().equals(SimpleName.class) || o.getClass().equals(QualifiedName.class)
|| o.getClass().equals(CastExpression.class) || o.getClass().equals(InfixExpression.class)
|| o.getClass().equals(PrefixExpression.class) || o.getClass().equals(InstanceofExpression.class)
|| o.getClass().equals(ThisExpression.class) || o.getClass().equals(ConditionalExpression.class))
return true;
return false;
}
private String getLiteralValue(Expression expression)
{
if (expression instanceof NumberLiteral)
{
return ((NumberLiteral)expression).getToken();
}
else if (expression instanceof CharacterLiteral)
{
return String.valueOf(((CharacterLiteral)expression).charValue());
}
else if (expression instanceof StringLiteral)
{
return ((StringLiteral)expression).getLiteralValue();
}
else
{
return null;
}
}
private void hasMagicNumbers() {
NumberLiteralVisitor visitor = new NumberLiteralVisitor();
methodMetrics.getMethod().getMethodDeclaration().accept(visitor);
List<NumberLiteral> literals = visitor.getNumberLiteralsExpressions();
if( literals.size() < 1 ) {
return;
}
for(NumberLiteral singleNumberLiteral : literals) {
if( isLiteralValid(singleNumberLiteral) ) {
addToSmells(initializeCodeSmell(MAGIC_NUMBER));
}
}
}
@Override
public boolean visit(final NumberLiteral node) {
String value = node.getToken();
if ((value.startsWith("0x") || value.startsWith("0X"))) {
int _length = value.length();
int _minus = (_length - 1);
final char lastChar = value.charAt(_minus);
String _lowerCase = Character.valueOf(lastChar).toString().toLowerCase();
boolean _equals = Objects.equal("l", _lowerCase);
if (_equals) {
int _length_1 = value.length();
int _minus_1 = (_length_1 - 1);
String _substring = value.substring(0, _minus_1);
String _plus = (_substring + "#");
String _plus_1 = (_plus + Character.valueOf(lastChar));
value = _plus_1;
}
final int binExponent = value.indexOf("p");
if ((binExponent >= 2)) {
boolean _endsWith = value.endsWith("f");
if (_endsWith) {
String _string = Float.valueOf(value).toString();
String _plus_2 = (_string + "f");
value = _plus_2;
} else {
value = Double.valueOf(value).toString();
}
}
}
this.appendToBuffer(value);
return false;
}
public boolean visit(NumberLiteral node) {
numberLiterals.add(node.toString());
if(current.getUserObject() != null) {
AnonymousClassDeclarationObject anonymous = (AnonymousClassDeclarationObject)current.getUserObject();
anonymous.getNumberLiterals().add(node.toString());
}
return super.visit(node);
}
private static Expression createInfixInvocationFromPostPrefixExpression(InfixExpression.Operator operator, Expression getterExpression, AST ast, ITypeBinding variableType, boolean is50OrHigher) {
InfixExpression infix= ast.newInfixExpression();
infix.setLeftOperand(getterExpression);
infix.setOperator(operator);
NumberLiteral number= ast.newNumberLiteral();
number.setToken("1"); //$NON-NLS-1$
infix.setRightOperand(number);
ITypeBinding infixType= infix.resolveTypeBinding();
return createNarrowCastIfNessecary(infix, infixType, ast, variableType, is50OrHigher);
}
private IVariableBinding getIndexBindingFromFragment(VariableDeclarationFragment fragment) {
Expression initializer= fragment.getInitializer();
if (!(initializer instanceof NumberLiteral))
return null;
NumberLiteral number= (NumberLiteral)initializer;
if (!LITERAL_0.equals(number.getToken()))
return null;
return (IVariableBinding)fragment.getName().resolveBinding();
}
private boolean isOneLiteral(Expression expression) {
if (!(expression instanceof NumberLiteral))
return false;
NumberLiteral literal= (NumberLiteral)expression;
return LITERAL_1.equals(literal.getToken());
}
/**
* Generates a {@link VariableDeclarationExpression}, which initializes the loop variable to
* iterate over an array.
*
* @param ast the current {@link AST} instance
* @param loopVariableName the name of the variable which should be initialized
* @return a filled {@link VariableDeclarationExpression}, declaring a int variable, which is
* initializes with 0
*/
private VariableDeclarationExpression getForInitializer(AST ast, SimpleName loopVariableName) {
// initializing fragment
VariableDeclarationFragment firstDeclarationFragment= ast.newVariableDeclarationFragment();
firstDeclarationFragment.setName(loopVariableName);
NumberLiteral startIndex= ast.newNumberLiteral();
firstDeclarationFragment.setInitializer(startIndex);
// declaration
VariableDeclarationExpression variableDeclaration= ast.newVariableDeclarationExpression(firstDeclarationFragment);
PrimitiveType variableType= ast.newPrimitiveType(PrimitiveType.INT);
variableDeclaration.setType(variableType);
return variableDeclaration;
}
public boolean instanceOf(Expression expression) {
if(expression instanceof BooleanLiteral || expression instanceof CharacterLiteral || expression instanceof StringLiteral ||
expression instanceof NullLiteral || expression instanceof NumberLiteral || expression instanceof TypeLiteral)
return true;
else
return false;
}
public boolean visit(NumberLiteral expr) {
/*
* Number literal nodes.
*/
styledString.append(expr.getToken(), determineDiffStyle(expr, new StyledStringStyler(ordinaryStyle)));
return false;
}
public Expression returnLong(long val) {
NumberLiteral num = ast.newNumberLiteral(""+val);
num.setProperty(TYPEBIND_PROP, StructCache.FieldType.LONG);
return num;
}
public Expression returnInt(int val) {
NumberLiteral num = ast.newNumberLiteral(""+val);
num.setProperty(TYPEBIND_PROP, StructCache.FieldType.INT);
return num;
}
public boolean visit(NumberLiteral node)
{
numberLiteralsExpressions.add(node);
return true;
}
public List<NumberLiteral> getNumberLiteralsExpressions() {
return numberLiteralsExpressions;
}
private boolean isLiteralValid(NumberLiteral singleNumberLiteral) {
boolean isValid = isNotZeroOrOne(singleNumberLiteral) && isNotArrayInitialization(singleNumberLiteral);
return isValid;
}
private boolean isNotArrayInitialization(NumberLiteral singleNumberLiteral) {
return singleNumberLiteral.getParent().getNodeType() != ASTNode.ARRAY_INITIALIZER;
}
@Override
public void endVisit(NumberLiteral node) {
// Leaf node.
}
protected static boolean isNumber(Expression exp, int number) {
return exp instanceof NumberLiteral && parseInt(((NumberLiteral) exp).getToken()) == number;
}
public boolean isConstantArrayIndex(final Expression node) {
return (node instanceof NumberLiteral);
}
@Override
public void visit(NumberLiteral node) {
qty++;
}
private static boolean simpleNameOrNumberLiteral(Expression e) {
return e instanceof SimpleName || e instanceof NumberLiteral;
}
@Override
public void endVisit(NumberLiteral node) {
ITypeBinding typeBinding= node.resolveTypeBinding();
ImmutableTypeVariable2 cv= fTCModel.makeImmutableTypeVariable(typeBinding, node);
setConstraintVariable(node, cv);
}
@Override
public void endVisit(NumberLiteral node) {
// Leaf node.
}
@Override
public boolean visit(NumberLiteral node) {
if (node.subtreeMatch(fMatcher, fNodeToMatch))
return matches(node);
return super.visit(node);
}