Package org.aspectj.org.eclipse.jdt.internal.compiler.ast

Examples of org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration


      contents[contentsOffset++] = (byte) (signatureIndex >> 8);
      contents[contentsOffset++] = (byte) signatureIndex;
      attributesNumber++;
    }
    if (this.targetJDK >= ClassFileConstants.JDK1_5 && !this.creatingProblemType) {
      FieldDeclaration fieldDeclaration = fieldBinding.sourceField();
      if (fieldDeclaration != null) {
        Annotation[] annotations = fieldDeclaration.annotations;
        if (annotations != null) {
          attributesNumber += generateRuntimeAnnotations(annotations);
        }
View Full Code Here


    contents[contentsOffset++] = (byte) (fieldCount >> 8);
    contents[contentsOffset++] = (byte) fieldCount;

    FieldDeclaration[] fieldDecls = currentBinding.scope.referenceContext.fields;
    for (int i = 0, max = fieldDecls == null ? 0 : fieldDecls.length; i < max; i++) {
      FieldDeclaration fieldDecl = fieldDecls[i];
      if (fieldDecl.binding != null) {
        addFieldInfo(fieldDecl.binding);
      }
    }
View Full Code Here

  private ASTNode[] computeMergedMemberDeclarations(ASTNode[] nodes){
    ArrayList mergedNodes = new ArrayList();
    for (int i = 0, max = nodes.length; i < max; i++) {
      ASTNode currentNode = nodes[i];
      if (currentNode instanceof FieldDeclaration) {
        FieldDeclaration currentField = (FieldDeclaration) currentNode;
        if (mergedNodes.size() == 0) {
          // first node
          mergedNodes.add(currentNode);
        } else {
          // we need to check if the previous merged node is a field declaration
          ASTNode previousMergedNode = (ASTNode) mergedNodes.get(mergedNodes.size() - 1);
          if (previousMergedNode instanceof MultiFieldDeclaration) {
            // we merge the current node
            MultiFieldDeclaration multiFieldDeclaration = (MultiFieldDeclaration) previousMergedNode;
            int length = multiFieldDeclaration.declarations.length;
            System.arraycopy(multiFieldDeclaration.declarations, 0, multiFieldDeclaration.declarations= new FieldDeclaration[length+1], 0, length);
            multiFieldDeclaration.declarations[length] = currentField;
          } else if (previousMergedNode instanceof FieldDeclaration) {
            // need to check we need to create a multiple field declaration
            final FieldDeclaration previousFieldDeclaration = (FieldDeclaration)previousMergedNode;
            if (currentField.declarationSourceStart == previousFieldDeclaration.declarationSourceStart) {
              // we create a multi field declaration
              final MultiFieldDeclaration multiFieldDeclaration = new MultiFieldDeclaration(new FieldDeclaration[]{ previousFieldDeclaration, currentField});
              multiFieldDeclaration.annotations = previousFieldDeclaration.annotations;
              mergedNodes.set(mergedNodes.size() - 1, multiFieldDeclaration);
View Full Code Here

  }
 
  private ASTNode[] computeMergedMemberDeclarations(TypeDeclaration typeDeclaration){
   
    int fieldIndex = 0, fieldCount = (typeDeclaration.fields == null) ? 0 : typeDeclaration.fields.length;
    FieldDeclaration field = fieldCount == 0 ? null : typeDeclaration.fields[fieldIndex];
    int fieldStart = field == null ? Integer.MAX_VALUE : field.declarationSourceStart;

    int methodIndex = 0, methodCount = (typeDeclaration.methods == null) ? 0 : typeDeclaration.methods.length;
    AbstractMethodDeclaration method = methodCount == 0 ? null : typeDeclaration.methods[methodIndex];
    int methodStart = method == null ? Integer.MAX_VALUE : method.declarationSourceStart;

    int typeIndex = 0, typeCount = (typeDeclaration.memberTypes == null) ? 0 : typeDeclaration.memberTypes.length;
    TypeDeclaration type = typeCount == 0 ? null : typeDeclaration.memberTypes[typeIndex];
    int typeStart = type == null ? Integer.MAX_VALUE : type.declarationSourceStart;
 
    final int memberLength = fieldCount+methodCount+typeCount;
    ASTNode[] members = new ASTNode[memberLength];
    if (memberLength != 0) {
      int index = 0;
      int previousFieldStart = -1;
      do {
        if (fieldStart < methodStart && fieldStart < typeStart) {
          if (field.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {
            // filter out enum constants
            previousFieldStart = fieldStart;
            if (++fieldIndex < fieldCount) { // find next field if any
              fieldStart = (field = typeDeclaration.fields[fieldIndex]).declarationSourceStart;
            } else {
              fieldStart = Integer.MAX_VALUE;
            }
            continue;
          }
          // next member is a field
          if (fieldStart == previousFieldStart){
            ASTNode previousMember = members[index - 1];
            if (previousMember instanceof MultiFieldDeclaration) {
              MultiFieldDeclaration multiField = (MultiFieldDeclaration) previousMember;
              int length = multiField.declarations.length;
              System.arraycopy(multiField.declarations, 0, multiField.declarations=new FieldDeclaration[length+1], 0, length);
              multiField.declarations[length] = field;
            } else {
              FieldDeclaration fieldDeclaration = (FieldDeclaration)previousMember;
              final MultiFieldDeclaration multiFieldDeclaration = new MultiFieldDeclaration(new FieldDeclaration[]{ fieldDeclaration, field});
              multiFieldDeclaration.annotations = fieldDeclaration.annotations;
              members[index - 1] = multiFieldDeclaration;
            }
          } else {
View Full Code Here

 
    boolean ok = false;
    do {
      try {
        for (int i = 0, length = multipleFieldDeclarationsLength; i < length; i++) {
          FieldDeclaration fieldDeclaration = multiFieldDeclaration.declarations[i];
          /*
           * Field name
           */
          if (i == 0) {
            this.scribe.alignFragment(fieldAlignment, 0);
View Full Code Here

      boolean hasConstants = false;
      if (fieldDeclarations != null) {
        int length = fieldDeclarations.length;
        int enumConstantsLength = 0;
        for (int i = 0; i < length; i++) {
          FieldDeclaration fieldDeclaration = fieldDeclarations[i];
          if (fieldDeclaration.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {
            enumConstantsLength++;
          } else {
            break;
          }
        }
        hasConstants = enumConstantsLength != 0;
        if (enumConstantsLength > 1) {
          Alignment enumConstantsAlignment = this.scribe.createAlignment(
              "enumConstants",//$NON-NLS-1$
              this.preferences.alignment_for_enum_constants,
              enumConstantsLength,
              this.scribe.scanner.currentPosition,
              0, // we don't want to indent enum constants when splitting to a new line
              false);
          this.scribe.enterAlignment(enumConstantsAlignment);
          boolean ok = false;
          do {
            try {
              for (int i = 0; i < enumConstantsLength; i++) {
                this.scribe.alignFragment(enumConstantsAlignment, i);
                FieldDeclaration fieldDeclaration = fieldDeclarations[i];
                fieldDeclaration.traverse(this, typeDeclaration.initializerScope);
                if (isNextToken(TerminalTokens.TokenNameCOMMA)) {
                  this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_enum_declarations);
                  if (this.preferences.insert_space_after_comma_in_enum_declarations) {
                    this.scribe.space();
                  }
                  this.scribe.printTrailingComment();
                  if (fieldDeclaration.initialization instanceof QualifiedAllocationExpression) {
                    this.scribe.printNewLine();
                  }
                }
              }
              ok = true;
            } catch (AlignmentException e) {
              this.scribe.redoAlignment(e);
            }
          } while (!ok);
          this.scribe.exitAlignment(enumConstantsAlignment, true);
        } else {
          FieldDeclaration fieldDeclaration = fieldDeclarations[0];
          fieldDeclaration.traverse(this, typeDeclaration.initializerScope);
          if (isNextToken(TerminalTokens.TokenNameCOMMA)) {
            this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_enum_declarations);
            if (this.preferences.insert_space_after_comma_in_enum_declarations) {
              this.scribe.space();
            }
View Full Code Here

                }
              }
              Initializer initializer = (Initializer) member;
              initializer.traverse(this, null);
            } else {
              FieldDeclaration field = (FieldDeclaration) member;
              format(field, this, null, isChunkStart, i == 0);
            }
          } else if (member instanceof AbstractMethodDeclaration) {
            isChunkStart = memberAlignment.checkChunkStart(METHOD, i, this.scribe.scanner.currentPosition);
            format((AbstractMethodDeclaration) member, null, isChunkStart, i == 0);
View Full Code Here

                initializer.traverse(this, typeDeclaration.staticInitializerScope);
              } else {
                initializer.traverse(this, typeDeclaration.initializerScope);
              }         
            } else {
              FieldDeclaration field = (FieldDeclaration) member;
              if (field.isStatic()) {
                format(field, this, typeDeclaration.staticInitializerScope, isChunkStart, i == 0);
              } else {
                format(field, this, typeDeclaration.initializerScope, isChunkStart, i == 0);
              }         
            }
View Full Code Here

          }
          return null; // give up! kind of assuming here that the code has other problems (and they will be reported)
        }
        return methodDecl.annotations;
      } else if (realBinding instanceof FieldBinding) {
        FieldDeclaration fieldDecl = tDecl.declarationOf((FieldBinding) realBinding);
        return fieldDecl.annotations;
      }
    }
    return null;
  }
View Full Code Here

        if (methodScope.isInsideInitializer()) {
          // inside field or initializer, must find proper one
          TypeDeclaration type = methodScope.referenceType();
          int occurenceCount = 1;
          for (int i = 0, length = type.fields.length; i < length; i++) {
            FieldDeclaration field = type.fields[i];
            if (field.declarationSourceStart < elementPosition && field.declarationSourceEnd > elementPosition) {
              switch (field.getKind()) {
                case AbstractVariableDeclaration.FIELD :
                case AbstractVariableDeclaration.ENUM_CONSTANT :
                  newElement = parentType.getField(new String(field.name));
                  break;
                case AbstractVariableDeclaration.INITIALIZER :
                  newElement = parentType.getInitializer(occurenceCount);
                  break;
              }
              break;
            } else if (field.getKind() == AbstractVariableDeclaration.INITIALIZER) {
              occurenceCount++;
            }
          }
        } else {
          // method element
View Full Code Here

TOP

Related Classes of org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.