1 /*

     2  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.mirror.util;

    27 

    28 import com.sun.mirror.declaration.*;

    29 

    30 import java.util.SortedSet;

    31 import java.util.TreeSet;

    32 

    33 /**

    34  * A visitor for declarations that scans declarations contained within

    35  * the given declaration in source code order.  For example, when

    36  * visiting a class, the methods, fields, constructors, and nested

    37  * types of the class are also visited.

    38  *

    39  * To control the processing done on a declaration, users of this

    40  * class pass in their own visitors for pre and post processing.  The

    41  * preprocessing visitor is called before the contained declarations

    42  * are scanned; the postprocessing visitor is called after the

    43  * contained declarations are scanned.

    44  *

    45  * @deprecated All components of this API have been superseded by the

    46  * standardized annotation processing API.  The replacement for the

    47  * functionality of this class is {@link

    48  * javax.lang.model.util.SimpleElementVisitor6}.

    49  *

    50  * @author Joseph D. Darcy

    51  * @author Scott Seligman

    52  * @since 1.5

    53  */

    54 @Deprecated

    55 @SuppressWarnings("deprecation")

    56 class SourceOrderDeclScanner extends DeclarationScanner {

    57     static class SourceOrderComparator implements java.util.Comparator<Declaration> {

    58         SourceOrderComparator(){}

    59 

    60 

    61         static boolean equals(Declaration d1, Declaration d2) {

    62             return d1 == d2 || (d1 != null && d1.equals(d2));

    63         }

    64 

    65         private static class DeclPartialOrder extends com.sun.mirror.util.SimpleDeclarationVisitor {

    66             private int value = 1000;

    67             private static int staticAdjust(Declaration d) {

    68                 return d.getModifiers().contains(Modifier.STATIC)?0:1;

    69             }

    70 

    71             DeclPartialOrder() {}

    72 

    73             public int getValue() { return value; }

    74 

    75             @Override

    76             public void visitTypeParameterDeclaration(TypeParameterDeclaration d) {value = 0;}

    77 

    78             @Override

    79             public void visitEnumConstantDeclaration(EnumConstantDeclaration d) {value = 1;}

    80 

    81             @Override

    82             public void visitClassDeclaration(ClassDeclaration d) {value = 2 + staticAdjust(d);}

    83 

    84             @Override

    85             public void visitInterfaceDeclaration(InterfaceDeclaration d) {value = 4;}

    86 

    87             @Override

    88             public void visitEnumDeclaration(EnumDeclaration d) {value = 6;}

    89 

    90             @Override

    91             public void visitAnnotationTypeDeclaration(AnnotationTypeDeclaration d) {value = 8;}

    92 

    93             @Override

    94             public void visitFieldDeclaration(FieldDeclaration d) {value = 10 + staticAdjust(d);}

    95 

    96             @Override

    97             public void visitConstructorDeclaration(ConstructorDeclaration d) {value = 12;}

    98 

    99             @Override

   100             public void visitMethodDeclaration(MethodDeclaration d) {value = 14 + staticAdjust(d);}

   101         }

   102         @SuppressWarnings("cast")

   103         private int compareEqualPosition(Declaration d1, Declaration d2) {

   104             assert

   105                 (d1.getPosition() == d2.getPosition()) || // Handles two null positions.

   106                 (d1.getPosition().file().compareTo(d2.getPosition().file()) == 0 &&

   107                  d1.getPosition().line()   == d2.getPosition().line() &&

   108                  d1.getPosition().column() == d2.getPosition().column());

   109 

   110             DeclPartialOrder dpo1 = new DeclPartialOrder();

   111             DeclPartialOrder dpo2 = new DeclPartialOrder();

   112 

   113             d1.accept(dpo1);

   114             d2.accept(dpo2);

   115 

   116             int difference = dpo1.getValue() - dpo2.getValue();

   117             if (difference != 0)

   118                 return difference;

   119             else {

   120                 int result = d1.getSimpleName().compareTo(d2.getSimpleName());

   121                 if (result != 0)

   122                     return result;

   123                 return (int)( Long.signum((long)System.identityHashCode(d1) -

   124                                           (long)System.identityHashCode(d2)));

   125             }

   126         }

   127 

   128         public int compare(Declaration d1, Declaration d2) {

   129             if (equals(d1, d2))

   130                 return 0;

   131 

   132             SourcePosition p1 = d1.getPosition();

   133             SourcePosition p2 = d2.getPosition();

   134 

   135             if (p1 == null && p2 != null)

   136                 return 1;

   137             else if (p1 != null && p2 == null)

   138                 return -1;

   139             else if(p1 == null && p2 == null)

   140                 return compareEqualPosition(d1, d2);

   141             else {

   142                 assert p1 != null && p2 != null;

   143                 int fileComp = p1.file().compareTo(p2.file()) ;

   144                 if (fileComp == 0) {

   145                     long diff = (long)p1.line() - (long)p2.line();

   146                     if (diff == 0) {

   147                         diff = Long.signum((long)p1.column() - (long)p2.column());

   148                         if (diff != 0)

   149                             return (int)diff;

   150                         else {

   151                             // declarations may be two

   152                             // compiler-generated members with the

   153                             // same source position

   154                             return compareEqualPosition(d1, d2);

   155                         }

   156                     } else

   157                         return (diff<0)? -1:1;

   158                 } else

   159                     return fileComp;

   160             }

   161         }

   162     }

   163 

   164     final static java.util.Comparator<Declaration> comparator = new SourceOrderComparator();

   165 

   166     SourceOrderDeclScanner(DeclarationVisitor pre, DeclarationVisitor post) {

   167         super(pre, post);

   168     }

   169 

   170     /**

   171      * Visits a type declaration.

   172      *

   173      * @param d the declaration to visit

   174      */

   175     public void visitTypeDeclaration(TypeDeclaration d) {

   176         d.accept(pre);

   177 

   178         SortedSet<Declaration> decls = new

   179             TreeSet<Declaration>(SourceOrderDeclScanner.comparator) ;

   180 

   181         for(TypeParameterDeclaration tpDecl: d.getFormalTypeParameters()) {

   182             decls.add(tpDecl);

   183         }

   184 

   185         for(FieldDeclaration fieldDecl: d.getFields()) {

   186             decls.add(fieldDecl);

   187         }

   188 

   189         for(MethodDeclaration methodDecl: d.getMethods()) {

   190             decls.add(methodDecl);

   191         }

   192 

   193         for(TypeDeclaration typeDecl: d.getNestedTypes()) {

   194             decls.add(typeDecl);

   195         }

   196 

   197         for(Declaration decl: decls )

   198             decl.accept(this);

   199 

   200         d.accept(post);

   201     }

   202 

   203     /**

   204      * Visits a class declaration.

   205      *

   206      * @param d the declaration to visit

   207      */

   208     public void visitClassDeclaration(ClassDeclaration d) {

   209         d.accept(pre);

   210 

   211         SortedSet<Declaration> decls = new

   212             TreeSet<Declaration>(SourceOrderDeclScanner.comparator) ;

   213 

   214         for(TypeParameterDeclaration tpDecl: d.getFormalTypeParameters()) {

   215             decls.add(tpDecl);

   216         }

   217 

   218         for(FieldDeclaration fieldDecl: d.getFields()) {

   219             decls.add(fieldDecl);

   220         }

   221 

   222         for(MethodDeclaration methodDecl: d.getMethods()) {

   223             decls.add(methodDecl);

   224         }

   225 

   226         for(TypeDeclaration typeDecl: d.getNestedTypes()) {

   227             decls.add(typeDecl);

   228         }

   229 

   230         for(ConstructorDeclaration ctorDecl: d.getConstructors()) {

   231             decls.add(ctorDecl);

   232         }

   233 

   234         for(Declaration decl: decls )

   235             decl.accept(this);

   236 

   237         d.accept(post);

   238     }

   239 

   240     public void visitExecutableDeclaration(ExecutableDeclaration d) {

   241         d.accept(pre);

   242 

   243         SortedSet<Declaration> decls = new

   244             TreeSet<Declaration>(SourceOrderDeclScanner.comparator) ;

   245 

   246         for(TypeParameterDeclaration tpDecl: d.getFormalTypeParameters())

   247             decls.add(tpDecl);

   248 

   249         for(ParameterDeclaration pDecl: d.getParameters())

   250             decls.add(pDecl);

   251 

   252         for(Declaration decl: decls )

   253             decl.accept(this);

   254 

   255         d.accept(post);

   256     }

   257 

   258 }