コード例 #1
0
ファイル: LocalVariable.java プロジェクト: beefeather/ohl
  private IAnnotation getAnnotation(
      final org.eclipse.jdt.internal.compiler.ast.Annotation annotation,
      JavaElement parentElement) {
    final int typeStart = annotation.type.sourceStart();
    final int typeEnd = annotation.type.sourceEnd();
    final int sourceStart = annotation.sourceStart();
    final int sourceEnd = annotation.declarationSourceEnd;
    class LocalVarAnnotation extends Annotation {
      IMemberValuePair[] memberValuePairs;

      public LocalVarAnnotation(JavaElement localVar, String elementName) {
        super(localVar, elementName);
      }

      public IMemberValuePair[] getMemberValuePairs() throws JavaModelException {
        return this.memberValuePairs;
      }

      public ISourceRange getNameRange() throws JavaModelException {
        return new SourceRange(typeStart, typeEnd - typeStart + 1);
      }

      public ISourceRange getSourceRange() throws JavaModelException {
        return new SourceRange(sourceStart, sourceEnd - sourceStart + 1);
      }

      public boolean exists() {
        return this.parent.exists();
      }
    }
    String annotationName =
        new String(CharOperation.concatWith(annotation.type.getTypeName(), '.'));
    LocalVarAnnotation localVarAnnotation = new LocalVarAnnotation(parentElement, annotationName);
    org.eclipse.jdt.internal.compiler.ast.MemberValuePair[] astMemberValuePairs =
        annotation.memberValuePairs();
    int length;
    IMemberValuePair[] memberValuePairs;
    if (astMemberValuePairs == null || (length = astMemberValuePairs.length) == 0) {
      memberValuePairs = Annotation.NO_MEMBER_VALUE_PAIRS;
    } else {
      memberValuePairs = new IMemberValuePair[length];
      for (int i = 0; i < length; i++) {
        org.eclipse.jdt.internal.compiler.ast.MemberValuePair astMemberValuePair =
            astMemberValuePairs[i];
        MemberValuePair memberValuePair = new MemberValuePair(new String(astMemberValuePair.name));
        memberValuePair.value =
            getAnnotationMemberValue(memberValuePair, astMemberValuePair.value, localVarAnnotation);
        memberValuePairs[i] = memberValuePair;
      }
    }
    localVarAnnotation.memberValuePairs = memberValuePairs;
    return localVarAnnotation;
  }
コード例 #2
0
  // public int match(Reference node, MatchingNodeSet nodeSet) - SKIP IT
  public int match(Annotation node, MatchingNodeSet nodeSet) {
    if (!this.pattern.findReferences) return IMPOSSIBLE_MATCH;
    MemberValuePair[] pairs = node.memberValuePairs();
    if (pairs == null || pairs.length == 0) return IMPOSSIBLE_MATCH;

    int length = pairs.length;
    MemberValuePair pair = null;
    for (int i = 0; i < length; i++) {
      pair = node.memberValuePairs()[i];
      if (matchesName(this.pattern.selector, pair.name)) {
        ASTNode possibleNode = (node instanceof SingleMemberAnnotation) ? (ASTNode) node : pair;
        return nodeSet.addMatch(
            possibleNode, this.pattern.mustResolve ? POSSIBLE_MATCH : ACCURATE_MATCH);
      }
    }
    return IMPOSSIBLE_MATCH;
  }
コード例 #3
0
ファイル: AnnotationInfo.java プロジェクト: java10000/hasor
 private int readTargetValue(int offset) {
   int currentOffset = offset;
   int tag = u1At(currentOffset);
   currentOffset++;
   switch (tag) {
     case 'e':
       int utf8Offset = this.constantPoolOffsets[u2At(currentOffset)] - this.structOffset;
       char[] typeName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
       currentOffset += 2;
       if (typeName.length == 34
           && CharOperation.equals(typeName, ConstantPool.JAVA_LANG_ANNOTATION_ELEMENTTYPE)) {
         utf8Offset = this.constantPoolOffsets[u2At(currentOffset)] - this.structOffset;
         char[] constName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
         this.standardAnnotationTagBits |= Annotation.getTargetElementType(constName);
       }
       currentOffset += 2;
       break;
     case 'B':
     case 'C':
     case 'D':
     case 'F':
     case 'I':
     case 'J':
     case 'S':
     case 'Z':
     case 's':
     case 'c':
       currentOffset += 2;
       break;
     case '@':
       // none of the supported standard annotation are in the nested
       // level.
       currentOffset = scanAnnotation(currentOffset, false, false);
       break;
     case '[':
       int numberOfValues = u2At(currentOffset);
       currentOffset += 2;
       if (numberOfValues == 0) {
         this.standardAnnotationTagBits |= TagBits.AnnotationTarget;
       } else {
         for (int i = 0; i < numberOfValues; i++) currentOffset = readTargetValue(currentOffset);
       }
       break;
     default:
       throw new IllegalStateException();
   }
   return currentOffset;
 }
コード例 #4
0
ファイル: Eclipse.java プロジェクト: barneypitt/lombok
  /** Provides AnnotationValues with the data it needs to do its thing. */
  public static <A extends java.lang.annotation.Annotation> AnnotationValues<A> createAnnotation(
      Class<A> type, final Node annotationNode) {
    final Annotation annotation = (Annotation) annotationNode.get();
    Map<String, AnnotationValue> values = new HashMap<String, AnnotationValue>();

    final MemberValuePair[] pairs = annotation.memberValuePairs();
    for (Method m : type.getDeclaredMethods()) {
      if (!Modifier.isPublic(m.getModifiers())) continue;
      String name = m.getName();
      List<String> raws = new ArrayList<String>();
      List<Object> guesses = new ArrayList<Object>();
      Expression fullExpression = null;
      Expression[] expressions = null;

      if (pairs != null)
        for (MemberValuePair pair : pairs) {
          char[] n = pair.name;
          String mName = n == null ? "value" : new String(pair.name);
          if (mName.equals(name)) fullExpression = pair.value;
        }

      boolean isExplicit = fullExpression != null;

      if (isExplicit) {
        if (fullExpression instanceof ArrayInitializer) {
          expressions = ((ArrayInitializer) fullExpression).expressions;
        } else expressions = new Expression[] {fullExpression};
        if (expressions != null)
          for (Expression ex : expressions) {
            StringBuffer sb = new StringBuffer();
            ex.print(0, sb);
            raws.add(sb.toString());
            guesses.add(calculateValue(ex));
          }
      }

      final Expression fullExpr = fullExpression;
      final Expression[] exprs = expressions;

      values.put(
          name,
          new AnnotationValue(annotationNode, raws, guesses, isExplicit) {
            @Override
            public void setError(String message, int valueIdx) {
              Expression ex;
              if (valueIdx == -1) ex = fullExpr;
              else ex = exprs != null ? exprs[valueIdx] : null;

              if (ex == null) ex = annotation;

              int sourceStart = ex.sourceStart;
              int sourceEnd = ex.sourceEnd;

              annotationNode.addError(message, sourceStart, sourceEnd);
            }

            @Override
            public void setWarning(String message, int valueIdx) {
              Expression ex;
              if (valueIdx == -1) ex = fullExpr;
              else ex = exprs != null ? exprs[valueIdx] : null;

              if (ex == null) ex = annotation;

              int sourceStart = ex.sourceStart;
              int sourceEnd = ex.sourceEnd;

              annotationNode.addWarning(message, sourceStart, sourceEnd);
            }
          });
    }

    return new AnnotationValues<A>(type, values, annotationNode);
  }