<s> package org . eclipse . jdt . internal . compiler . parser ; import org . eclipse . jdt . internal . compiler . ast . ASTNode ; import org . eclipse . jdt . internal . compiler . ast . Annotation ; import org . eclipse . jdt . internal . compiler . ast . Expression ; import org . eclipse . jdt . internal . compiler . ast . MarkerAnnotation ; import org . eclipse . jdt . internal . compiler . ast . MemberValuePair ; import org . eclipse . jdt . internal . compiler . ast . NormalAnnotation ; import org . eclipse . jdt . internal . compiler . ast . SingleMemberAnnotation ; import org . eclipse . jdt . internal . compiler . ast . SingleNameReference ; import org . eclipse . jdt . internal . compiler . ast . TypeDeclaration ; import org . eclipse . jdt . internal . compiler . ast . TypeReference ; public class RecoveredAnnotation extends RecoveredElement { public static final int MARKER = 0 ; public static final int NORMAL = 1 ; public static final int SINGLE_MEMBER = 2 ; private int kind ; private int identifierPtr ; private int identifierLengthPtr ; private int sourceStart ; public boolean hasPendingMemberValueName ; public int memberValuPairEqualEnd = - 1 ; public Annotation annotation ; public RecoveredAnnotation ( int identifierPtr , int identifierLengthPtr , int sourceStart , RecoveredElement parent , int bracketBalance ) { super ( parent , bracketBalance ) ; this . kind = MARKER ; this . identifierPtr = identifierPtr ; this . identifierLengthPtr = identifierLengthPtr ; this . sourceStart = sourceStart ; } public RecoveredElement add ( TypeDeclaration typeDeclaration , int bracketBalanceValue ) { if ( this . annotation == null && ( typeDeclaration . bits & ASTNode . IsAnonymousType ) != 0 ) { return this ; } return super . add ( typeDeclaration , bracketBalanceValue ) ; } public RecoveredElement addAnnotationName ( int identPtr , int identLengthPtr , int annotationStart , int bracketBalanceValue ) { RecoveredAnnotation element = new RecoveredAnnotation ( identPtr , identLengthPtr , annotationStart , this , bracketBalanceValue ) ; return element ; } public RecoveredElement addAnnotation ( Annotation annot , int index ) { this . annotation = annot ; if ( this . parent != null ) return this . parent ; return this ; } public void updateFromParserState ( ) { Parser parser = parser ( ) ; if ( this . annotation == null && this . identifierPtr <= parser . identifierPtr ) { Annotation annot = null ; boolean needUpdateRParenPos = false ; MemberValuePair pendingMemberValueName = null ; if ( this . hasPendingMemberValueName && this . identifierPtr < parser . identifierPtr ) { char [ ] memberValueName = parser . identifierStack [ this . identifierPtr + 1 ] ; long pos = parser . identifierPositionStack [ this . identifierPtr + 1 ] ; int start = ( int ) ( pos >>> 32 ) ; int end = ( int ) pos ; int valueEnd = this . memberValuPairEqualEnd > - 1 ? this . memberValuPairEqualEnd : end ; SingleNameReference fakeExpression = new SingleNameReference ( RecoveryScanner . FAKE_IDENTIFIER , ( ( ( long ) valueEnd + 1 ) << 32 ) + ( valueEnd ) ) ; pendingMemberValueName = new MemberValuePair ( memberValueName , start , end , fakeExpression ) ; } parser . identifierPtr = this . identifierPtr ; parser . identifierLengthPtr = this . identifierLengthPtr ; TypeReference typeReference = parser . getAnnotationType ( ) ; switch ( this . kind ) { case NORMAL : if ( parser . astPtr > - 1 && parser . astStack [ parser . astPtr ] instanceof MemberValuePair ) { MemberValuePair [ ] memberValuePairs = null ; int argLength = parser . astLengthStack [ parser . astLengthPtr ] ; int argStart = parser . astPtr - argLength + 1 ; if ( argLength > 0 ) { int annotationEnd ; if ( pendingMemberValueName != null ) { memberValuePairs = new MemberValuePair [ argLength + 1 ] ; System . arraycopy ( parser . astStack , argStart , memberValuePairs , 0 , argLength ) ; parser . astLengthPtr -- ; parser . astPtr -= argLength ; memberValuePairs [ argLength ] = pendingMemberValueName ; annotationEnd = pendingMemberValueName . sourceEnd ; } else { memberValuePairs = new MemberValuePair [ argLength ] ; System . arraycopy ( parser . astStack , argStart , memberValuePairs , 0 , argLength ) ; parser . astLengthPtr -- ; parser . astPtr -= argLength ; MemberValuePair lastMemberValuePair = memberValuePairs [ memberValuePairs . length - 1 ] ; annotationEnd = lastMemberValuePair . value != null ? lastMemberValuePair . value instanceof Annotation ? ( ( Annotation ) lastMemberValuePair . value ) . declarationSourceEnd : lastMemberValuePair . value . sourceEnd : lastMemberValuePair . sourceEnd ; } NormalAnnotation normalAnnotation = new NormalAnnotation ( typeReference , this . sourceStart ) ; normalAnnotation . memberValuePairs = memberValuePairs ; normalAnnotation . declarationSourceEnd = annotationEnd ; normalAnnotation . bits |= ASTNode . IsRecovered ; annot = normalAnnotation ; needUpdateRParenPos = true ; } } break ; case SINGLE_MEMBER : if ( parser . expressionPtr > - 1 ) { Expression memberValue = parser . expressionStack [ parser . expressionPtr -- ] ; SingleMemberAnnotation singleMemberAnnotation = new SingleMemberAnnotation ( typeReference , this . sourceStart ) ; singleMemberAnnotation . memberValue = memberValue ; singleMemberAnnotation . declarationSourceEnd = memberValue . sourceEnd ; singleMemberAnnotation . bits |= ASTNode . IsRecovered ; annot = singleMemberAnnotation ; needUpdateRParenPos = true ; } break ; } if ( ! needUpdateRParenPos ) { if ( pendingMemberValueName != null ) { NormalAnnotation normalAnnotation = new NormalAnnotation ( typeReference , this . sourceStart ) ; normalAnnotation . memberValuePairs = new MemberValuePair [ ] { pendingMemberValueName } ; normalAnnotation . declarationSourceEnd = pendingMemberValueName . value . sourceEnd ; normalAnnotation . bits |= ASTNode . IsRecovered ; annot = normalAnnotation ; } else { MarkerAnnotation markerAnnotation = new MarkerAnnotation ( typeReference , this . sourceStart ) ; markerAnnotation . declarationSourceEnd = markerAnnotation . sourceEnd ; markerAnnotation . bits |= ASTNode . IsRecovered ; annot = markerAnnotation ; } } parser . currentElement = addAnnotation ( annot , this . identifierPtr ) ; parser . annotationRecoveryCheckPoint ( annot . sourceStart , annot . declarationSourceEnd ) ; if ( this . parent != null ) { this . parent . updateFromParserState ( ) ; } } } public ASTNode parseTree ( ) { return this . annotation ; } public void resetPendingModifiers ( ) { if ( this . parent != null ) this . parent . resetPendingModifiers ( ) ; } public void setKind ( int kind ) { this . kind = kind ; } public int sourceEnd ( ) { if ( this . annotation == null ) { Parser parser = parser ( ) ; if ( this . identifierPtr < parser . identifierPositionStack . length ) { return ( int ) parser . identifierPositionStack [ this . identifierPtr ] ; } else { return this . sourceStart ; } } return this . annotation . declarationSourceEnd ; } public String toString ( int tab ) { if ( this . annotation != null ) { return tabString ( tab ) + "" + this . annotation . print ( tab + 1 , new StringBuffer ( 10 ) ) ; } else { return tabString ( tab ) + "" + this . identifierPtr + "" + this . identifierLengthPtr + "n" ; } } public Annotation updatedAnnotationReference ( ) { return this . annotation ; } public RecoveredElement updateOnClosingBrace ( int braceStart , int braceEnd ) { if ( this . bracketBalance > 0 ) { this . bracketBalance -- ; return this ; } if ( this . parent != null ) { return this . parent . updateOnClosingBrace ( braceStart , braceEnd ) ; } return this ; } public void updateParseTree ( ) { updatedAnnotationReference ( ) ; } } </s>