home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / VPage / Java.bin / CLASSES.ZIP / sun / tools / javadoc / DocumentationGenerator.class (.txt) next >
Encoding:
Java Class File  |  1997-07-08  |  18.8 KB  |  1,028 lines
  1. package sun.tools.javadoc;
  2.  
  3. import java.io.BufferedWriter;
  4. import java.io.File;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.OutputStreamWriter;
  8. import java.io.PrintWriter;
  9. import java.lang.reflect.Modifier;
  10. import java.util.Enumeration;
  11. import java.util.Hashtable;
  12. import java.util.StringTokenizer;
  13. import java.util.Vector;
  14. import sun.tools.java.ClassDeclaration;
  15. import sun.tools.java.ClassDefinition;
  16. import sun.tools.java.ClassNotFound;
  17. import sun.tools.java.Constants;
  18. import sun.tools.java.Environment;
  19. import sun.tools.java.FieldDefinition;
  20. import sun.tools.java.Identifier;
  21. import sun.tools.java.Type;
  22. import sun.tools.javac.BatchEnvironment;
  23. import sun.tools.javac.SourceClass;
  24.  
  25. abstract class DocumentationGenerator implements Constants {
  26.    BatchEnvironment env;
  27.    Hashtable classesToDocument;
  28.    static String encoding;
  29.    private static final Identifier idIOException = Identifier.lookup("java.io.IOException");
  30.    static ClassDeclaration exDecl;
  31.    static ClassDeclaration errorDecl;
  32.  
  33.    public void init(Vector var1, String var2) {
  34.       encoding = var2;
  35.       this.env = Main.env;
  36.       this.classesToDocument = new Hashtable(var1.size() * 2 + 1);
  37.       Enumeration var3 = var1.elements();
  38.  
  39.       while(var3.hasMoreElements()) {
  40.          ClassDeclaration var4 = (ClassDeclaration)var3.nextElement();
  41.          this.classesToDocument.put(var4, var4);
  42.       }
  43.  
  44.    }
  45.  
  46.    public ClassDeclaration getClassDeclaration(ClassDefinition var1, Identifier var2) {
  47.       Object var3;
  48.       if (var1 instanceof SourceClass) {
  49.          SourceClass var4 = (SourceClass)var1;
  50.          var3 = var4.getImports().newEnvironment(this.env);
  51.       } else {
  52.          var3 = this.env;
  53.       }
  54.  
  55.       Identifier var5 = var1.resolveName((Environment)var3, var2);
  56.       return this.env.getClassDeclaration(var5);
  57.    }
  58.  
  59.    public ClassDefinition getClassDefinition(ClassDeclaration var1) throws ClassNotFound {
  60.       if (var1.getName().isInner()) {
  61.          throw new ClassNotFound(var1.getName());
  62.       } else {
  63.          ClassDefinition var2 = var1.getClassDefinition(this.env);
  64.          var2.resolveTypeStructure(this.env);
  65.          return var2;
  66.       }
  67.    }
  68.  
  69.    public String getReferenceName(Identifier var1) {
  70.       var1 = Identifier.lookup(var1.getQualifier(), var1.getFlatName());
  71.       return var1.toString();
  72.    }
  73.  
  74.    public static String getReferenceName(FieldDefinition var0) {
  75.       if (var0.isConstructor()) {
  76.          Identifier var1 = var0.getClassDeclaration().getName();
  77.          var1 = var1.getFlatName();
  78.          return var1.getName().toString();
  79.       } else {
  80.          return var0.getName().toString();
  81.       }
  82.    }
  83.  
  84.    boolean shouldDocument(ClassDeclaration var1) {
  85.       return this.classesToDocument.containsKey(var1);
  86.    }
  87.  
  88.    boolean shouldDocument(ClassDefinition var1) {
  89.       return this.shouldDocument(var1.getClassDeclaration());
  90.    }
  91.  
  92.    static boolean shouldDocument(FieldDefinition var0) {
  93.       return var0.isSynthetic() ? false : Main.showAccess.checkField(var0);
  94.    }
  95.  
  96.    static Vector allVariables(ClassDefinition var0) {
  97.       Vector var1 = new Vector();
  98.  
  99.       for(FieldDefinition var2 = var0.getFirstField(); var2 != null; var2 = var2.getNextField()) {
  100.          if (var2.isVariable() && shouldDocument(var2)) {
  101.             var1.addElement(var2);
  102.          }
  103.       }
  104.  
  105.       return var1;
  106.    }
  107.  
  108.    static Vector allConstructors(ClassDefinition var0) {
  109.       Vector var1 = new Vector();
  110.  
  111.       for(FieldDefinition var2 = var0.getFirstField(); var2 != null; var2 = var2.getNextField()) {
  112.          if (var2.isConstructor() && shouldDocument(var2)) {
  113.             var1.addElement(var2);
  114.          }
  115.       }
  116.  
  117.       return var1;
  118.    }
  119.  
  120.    static Vector allMethods(ClassDefinition var0) {
  121.       Vector var1 = new Vector();
  122.  
  123.       for(FieldDefinition var2 = var0.getFirstField(); var2 != null; var2 = var2.getNextField()) {
  124.          if (var2.isMethod() && !var2.isConstructor() && shouldDocument(var2)) {
  125.             var1.addElement(var2);
  126.          }
  127.       }
  128.  
  129.       return var1;
  130.    }
  131.  
  132.    static Vector localFieldsOf(ClassDefinition var0, Vector var1) {
  133.       Vector var2 = new Vector();
  134.       Enumeration var3 = var1.elements();
  135.  
  136.       while(var3.hasMoreElements()) {
  137.          FieldDefinition var4 = (FieldDefinition)var3.nextElement();
  138.          if (var4.getClassDefinition().equals(var0) && var4.getClassDeclaration() == var4.getDefiningClassDeclaration()) {
  139.             var2.addElement(var4);
  140.          }
  141.       }
  142.  
  143.       return var2;
  144.    }
  145.  
  146.    Vector superclassesOf(ClassDeclaration var1) {
  147.       if (var1 == null) {
  148.          return new Vector();
  149.       } else {
  150.          try {
  151.             ClassDeclaration var2 = this.getClassDefinition(var1).getSuperClass();
  152.             Vector var3 = this.superclassesOf(var2);
  153.             var3.addElement(var1);
  154.             return var3;
  155.          } catch (ClassNotFound var4) {
  156.             System.out.println(Main.getText("doc.Warning_superclass_info", var1.getName().toString()));
  157.             return new Vector();
  158.          }
  159.       }
  160.    }
  161.  
  162.    static Vector mergeDoc(String var0) {
  163.       Vector var1 = new Vector();
  164.       StringTokenizer var2 = new StringTokenizer(var0, "\n");
  165.  
  166.       while(var2.hasMoreTokens()) {
  167.          String var3 = var2.nextToken();
  168.          String var4 = var3.trim();
  169.          if (var4.length() != 0) {
  170.             if (var4.charAt(0) == '@') {
  171.                var1.addElement(var4);
  172.             } else if (var1.size() == 0) {
  173.                var1.addElement("@comment " + var3);
  174.             } else {
  175.                int var5 = var1.size() - 1;
  176.                var1.setElementAt(var1.elementAt(var5) + "\n" + var3, var5);
  177.             }
  178.          }
  179.       }
  180.  
  181.       return var1;
  182.    }
  183.  
  184.    abstract String commentString(String var1);
  185.  
  186.    abstract String returnString(String var1);
  187.  
  188.    abstract String versionString(String var1);
  189.  
  190.    abstract String authorString(String var1);
  191.  
  192.    String deprecatedString(String var1) {
  193.       return var1;
  194.    }
  195.  
  196.    String getComment(Vector var1) {
  197.       Enumeration var2 = var1.elements();
  198.  
  199.       while(var2.hasMoreElements()) {
  200.          String var3 = (String)var2.nextElement();
  201.          if (var3.startsWith("@comment")) {
  202.             return this.commentString(var3.substring(8).trim());
  203.          }
  204.       }
  205.  
  206.       return null;
  207.    }
  208.  
  209.    String getReturn(Vector var1) {
  210.       String var2 = null;
  211.       Enumeration var3 = var1.elements();
  212.  
  213.       while(var3.hasMoreElements()) {
  214.          String var4 = (String)var3.nextElement();
  215.          if (var4.startsWith("@return")) {
  216.             var4 = var4.substring(7).trim();
  217.             if (var4.length() == 0) {
  218.                System.out.println(Main.getText("doc.Warning_Empty_statement", "@return"));
  219.             } else if (var2 == null) {
  220.                var2 = this.returnString(var4);
  221.             } else {
  222.                System.out.println(Main.getText("doc.Warning_Multiple_statements", "@return"));
  223.             }
  224.          }
  225.       }
  226.  
  227.       return var2;
  228.    }
  229.  
  230.    String getVersion(Vector var1) {
  231.       if (!Main.showVersion) {
  232.          return null;
  233.       } else {
  234.          String var2 = null;
  235.          Enumeration var3 = var1.elements();
  236.  
  237.          while(var3.hasMoreElements()) {
  238.             String var4 = (String)var3.nextElement();
  239.             if (var4.startsWith("@version")) {
  240.                var4 = var4.substring(8).trim();
  241.                if (var4.length() == 0) {
  242.                   System.out.println(Main.getText("doc.Warning_Empty_statement", "@version"));
  243.                } else if (var2 == null) {
  244.                   var2 = this.versionString(var4);
  245.                } else {
  246.                   System.out.println(Main.getText("doc.Warning_Multiple_statements", "@version"));
  247.                }
  248.             }
  249.          }
  250.  
  251.          return var2;
  252.       }
  253.    }
  254.  
  255.    String getDeprecated(Vector var1) {
  256.       if (!Main.showDeprecated) {
  257.          return null;
  258.       } else {
  259.          String var2 = null;
  260.          Enumeration var3 = var1.elements();
  261.  
  262.          while(var3.hasMoreElements()) {
  263.             String var4 = (String)var3.nextElement();
  264.             if (var4.startsWith("@deprecated")) {
  265.                var4 = var4.substring(11).trim();
  266.                if (var2 == null) {
  267.                   var2 = this.deprecatedString(var4);
  268.                } else {
  269.                   System.out.println(Main.getText("doc.Warning_Multiple_statements", "@deprecated"));
  270.                }
  271.             }
  272.          }
  273.  
  274.          return var2;
  275.       }
  276.    }
  277.  
  278.    Vector getSees(Vector var1, ClassDeclaration var2) {
  279.       Vector var3 = null;
  280.       Enumeration var4 = var1.elements();
  281.  
  282.       while(var4.hasMoreElements()) {
  283.          String var5 = (String)var4.nextElement();
  284.          if (var5.startsWith("@see")) {
  285.             var5 = var5.substring(4).trim();
  286.             if (var5.length() == 0) {
  287.                System.out.println(Main.getText("doc.Warning_Empty_statement", "@see"));
  288.             } else {
  289.                if (var3 == null) {
  290.                   var3 = new Vector();
  291.                }
  292.  
  293.                this.parseSeeString(var5, var2, var3);
  294.             }
  295.          }
  296.       }
  297.  
  298.       return var3;
  299.    }
  300.  
  301.    String getAuthors(Vector var1) {
  302.       if (!Main.showAuthors) {
  303.          return null;
  304.       } else {
  305.          String var2 = null;
  306.          Enumeration var3 = var1.elements();
  307.  
  308.          while(var3.hasMoreElements()) {
  309.             String var4 = (String)var3.nextElement();
  310.             if (var4.startsWith("@author")) {
  311.                var4 = var4.substring(7).trim();
  312.                if (var4.length() == 0) {
  313.                   System.out.println(Main.getText("doc.Warning_Empty_statement", "@author"));
  314.                } else if (var2 == null) {
  315.                   var2 = this.authorString(var4);
  316.                } else {
  317.                   var2 = var2 + ", " + this.authorString(var4);
  318.                }
  319.             }
  320.          }
  321.  
  322.          return var2;
  323.       }
  324.    }
  325.  
  326.    static Vector getParameters(Vector var0) {
  327.       Vector var1 = null;
  328.       Enumeration var2 = var0.elements();
  329.  
  330.       while(var2.hasMoreElements()) {
  331.          String var3 = (String)var2.nextElement();
  332.          if (var3.startsWith("@param")) {
  333.             int var4 = 0;
  334.  
  335.             for(var3 = var3.substring(6).trim(); var4 < var3.length() && var3.charAt(var4) != ' ' && var3.charAt(var4) != '\t'; ++var4) {
  336.             }
  337.  
  338.             if (var4 < var3.length()) {
  339.                if (var1 == null) {
  340.                   var1 = new Vector();
  341.                }
  342.  
  343.                var1.addElement(var3.substring(0, var4));
  344.                var1.addElement(var3.substring(var4).trim());
  345.             } else {
  346.                System.out.println(Main.getText("doc.Warning_Empty_statement", "@param"));
  347.             }
  348.          }
  349.       }
  350.  
  351.       return var1;
  352.    }
  353.  
  354.    Vector getThrows(Vector var1, FieldDefinition var2) {
  355.       Vector var3 = new Vector();
  356.       Enumeration var4 = var1.elements();
  357.  
  358.       while(var4.hasMoreElements()) {
  359.          String var5 = (String)var4.nextElement();
  360.          if (var5.startsWith("@exception")) {
  361.             int var6 = 0;
  362.  
  363.             for(var5 = var5.substring(10).trim(); var6 < var5.length() && var5.charAt(var6) != ' ' && var5.charAt(var6) != '\t' && var5.charAt(var6) != '\n'; ++var6) {
  364.             }
  365.  
  366.             if (var6 >= var5.length()) {
  367.                System.out.println(Main.getText("doc.Warning_Empty_statement", "@exception"));
  368.             } else {
  369.                Identifier var7 = Identifier.lookup(var5.substring(0, var6));
  370.                ClassDeclaration var8 = this.getClassDeclaration(var2.getClassDefinition(), var7);
  371.                var3.addElement(var8);
  372.                var3.addElement(var5.substring(var6).trim());
  373.             }
  374.          }
  375.       }
  376.  
  377.       ClassDeclaration var17 = this.env.getClassDeclaration(Constants.idJavaLangError);
  378.       ClassDeclaration var18 = this.env.getClassDeclaration(Constants.idJavaLangRuntimeException);
  379.       ClassDeclaration var19 = this.env.getClassDeclaration(idIOException);
  380.       ClassDeclaration[] var20 = var2.getExceptions(this.env);
  381.  
  382.       label91:
  383.       for(int var9 = 0; var9 < var20.length; ++var9) {
  384.          ClassDeclaration var10 = var20[var9];
  385.  
  386.          try {
  387.             ClassDefinition var11 = this.getClassDefinition(var10);
  388.             if (!var11.subClassOf(this.env, var17) && !var11.subClassOf(this.env, var18) && !var11.subClassOf(this.env, var19)) {
  389.                for(int var12 = 0; var12 < var3.size(); var12 += 2) {
  390.                   if (var11.subClassOf(this.env, (ClassDeclaration)var3.elementAt(var12))) {
  391.                      continue label91;
  392.                   }
  393.                }
  394.  
  395.                System.out.println(Main.getText("doc.Method_there_is_no_exception", var2.toString(), var11.toString(), "@exception"));
  396.             }
  397.          } catch (ClassNotFound var15) {
  398.             System.out.println(Main.getText("doc.Could_not_find", var15.name.toString()));
  399.          }
  400.       }
  401.  
  402.       label72:
  403.       for(int var21 = 0; var21 < var3.size(); var21 += 2) {
  404.          ClassDeclaration var22 = (ClassDeclaration)var3.elementAt(var21);
  405.  
  406.          try {
  407.             ClassDefinition var23 = this.getClassDefinition(var22);
  408.             if (!var23.subClassOf(this.env, var17) && !var23.subClassOf(this.env, var18) && !var23.subClassOf(this.env, var19)) {
  409.                for(int var13 = 0; var13 < var20.length; ++var13) {
  410.                   if (var23.subClassOf(this.env, var20[var13])) {
  411.                      continue label72;
  412.                   }
  413.                }
  414.  
  415.                System.out.println(Main.getText("doc.Method_Throw_does_not_declare", var2.toString(), var22.toString()));
  416.             }
  417.          } catch (ClassNotFound var14) {
  418.             System.out.println(Main.getText("doc.Could_not_find", var14.name.toString()));
  419.          }
  420.       }
  421.  
  422.       if (var3.size() == 0) {
  423.          return null;
  424.       } else {
  425.          return var3;
  426.       }
  427.    }
  428.  
  429.    FieldDefinition getOverride(FieldDefinition var1) {
  430.       FieldDefinition var2 = null;
  431.  
  432.       try {
  433.          if (!var1.isStatic() && !var1.isConstructor() && var1.getClassDefinition().getSuperClass() != null) {
  434.             var2 = this.getClassDefinition(var1.getClassDefinition().getSuperClass()).findMethod(this.env, var1.getName(), var1.getType());
  435.          }
  436.       } catch (ClassNotFound var3) {
  437.          var2 = null;
  438.       }
  439.  
  440.       return var2;
  441.    }
  442.  
  443.    boolean isException(ClassDeclaration var1) {
  444.       if (exDecl == null) {
  445.          Identifier var2 = Identifier.lookup("java.lang.Exception");
  446.          exDecl = this.env.getClassDeclaration(var2);
  447.       }
  448.  
  449.       try {
  450.          return this.getClassDefinition(var1).subClassOf(this.env, exDecl);
  451.       } catch (ClassNotFound var3) {
  452.          System.out.println(Main.getText("doc.Warning_Could_not_find_class_info", exDecl.getName().toString()));
  453.          return false;
  454.       }
  455.    }
  456.  
  457.    boolean isError(ClassDeclaration var1) {
  458.       if (errorDecl == null) {
  459.          Identifier var2 = Identifier.lookup("java.lang.Error");
  460.          errorDecl = this.env.getClassDeclaration(var2);
  461.       }
  462.  
  463.       try {
  464.          return this.getClassDefinition(var1).subClassOf(this.env, errorDecl);
  465.       } catch (ClassNotFound var3) {
  466.          System.out.println(Main.getText("doc.Warning_Could_not_find_class_info", errorDecl.getName().toString()));
  467.          return false;
  468.       }
  469.    }
  470.  
  471.    static PrintWriter openFile(String var0) {
  472.       if (Main.destDir != null) {
  473.          var0 = Main.destDir.getPath() + File.separator + var0;
  474.       }
  475.  
  476.       OutputStreamWriter var2;
  477.       try {
  478.          FileOutputStream var6 = new FileOutputStream(var0);
  479.          if (encoding == null) {
  480.             var2 = new OutputStreamWriter(var6);
  481.          } else {
  482.             var2 = new OutputStreamWriter(var6, encoding);
  483.          }
  484.       } catch (IOException var5) {
  485.          try {
  486.             String var3 = (new File(var0)).getParent();
  487.             if (var3 == null) {
  488.                throw new IOException();
  489.             }
  490.  
  491.             (new File(var3)).mkdirs();
  492.             FileOutputStream var1 = new FileOutputStream(var0);
  493.             if (encoding == null) {
  494.                var2 = new OutputStreamWriter(var1);
  495.             } else {
  496.                var2 = new OutputStreamWriter(var1, encoding);
  497.             }
  498.          } catch (IOException var4) {
  499.             throw new Error(Main.getText("doc.Can_not_open_output_file"));
  500.          }
  501.       }
  502.  
  503.       return new PrintWriter(new BufferedWriter(var2));
  504.    }
  505.  
  506.    String firstSentence(ClassDefinition var1) {
  507.       return this.firstSentence(var1.getDocumentation());
  508.    }
  509.  
  510.    String firstSentence(FieldDefinition var1) {
  511.       return this.firstSentence(this.getDocumentation(var1));
  512.    }
  513.  
  514.    private String firstSentence(String var1) {
  515.       if (var1 == null) {
  516.          return "";
  517.       } else {
  518.          int var2 = var1.length();
  519.          boolean var3 = false;
  520.  
  521.          for(int var4 = 0; var4 < var2; ++var4) {
  522.             switch (var1.charAt(var4)) {
  523.                case '\t':
  524.                case '\n':
  525.                case ' ':
  526.                   if (var3) {
  527.                      return var1.substring(0, var4);
  528.                   }
  529.                   break;
  530.                case '.':
  531.                   var3 = true;
  532.                   break;
  533.                case '@':
  534.                   return var1.substring(0, var4);
  535.                default:
  536.                   var3 = false;
  537.             }
  538.          }
  539.  
  540.          return var1;
  541.       }
  542.    }
  543.  
  544.    String getDocumentation(FieldDefinition var1) {
  545.       String var2 = var1.getDocumentation();
  546.       if (var2 == null && !var1.isVariable() && !var1.isConstructor()) {
  547.          while(var1 != null && var2 == null) {
  548.             ClassDeclaration var3 = var1.getClassDefinition().getSuperClass();
  549.             if (var3 == null) {
  550.                break;
  551.             }
  552.  
  553.             try {
  554.                var1 = this.getClassDefinition(var3).findMethod(this.env, var1.getName(), var1.getType());
  555.             } catch (ClassNotFound var4) {
  556.                System.out.println(Main.getText("doc.Warning_Could_not_find_class_info", var3.getName().toString()));
  557.                var1 = null;
  558.             }
  559.  
  560.             if (var1 != null) {
  561.                var2 = var1.getDocumentation();
  562.             }
  563.          }
  564.  
  565.          return var2 != null ? this.firstSentence(var2) : null;
  566.       } else {
  567.          return var2;
  568.       }
  569.    }
  570.  
  571.    String typeString(Type var1) {
  572.       switch (var1.getTypeCode()) {
  573.          case 0:
  574.             return "boolean";
  575.          case 1:
  576.             return "byte";
  577.          case 2:
  578.             return "char";
  579.          case 3:
  580.             return "short";
  581.          case 4:
  582.             return "int";
  583.          case 5:
  584.             return "long";
  585.          case 6:
  586.             return "float";
  587.          case 7:
  588.             return "double";
  589.          case 8:
  590.          default:
  591.             return "error";
  592.          case 9:
  593.             return this.typeString(var1.getElementType());
  594.          case 10:
  595.             return this.classString(this.env.getClassDeclaration(var1));
  596.          case 11:
  597.             return "void";
  598.       }
  599.    }
  600.  
  601.    String typeArrayString(Type var1) {
  602.       String var2;
  603.       for(var2 = ""; var1.getTypeCode() == 9; var1 = var1.getElementType()) {
  604.          var2 = var2 + "[]";
  605.       }
  606.  
  607.       return var2;
  608.    }
  609.  
  610.    static String modString(FieldDefinition var0) {
  611.       return modString(var0, true);
  612.    }
  613.  
  614.    static String modString(FieldDefinition var0, boolean var1) {
  615.       int var2 = var0.getModifiers();
  616.       if (!var1) {
  617.          var2 &= -33;
  618.       }
  619.  
  620.       String var3 = Modifier.toString(var2);
  621.       return var3.length() > 0 ? " " + var3 : "";
  622.    }
  623.  
  624.    private static int compare(ClassDeclaration var0, ClassDeclaration var1) {
  625.       Identifier var2 = var0.getName();
  626.       Identifier var3 = var1.getName();
  627.       int var4 = var2.getName().toString().compareTo(var3.getName().toString());
  628.       return var4 == 0 ? var2.getQualifier().toString().compareTo(var3.getQualifier().toString()) : var4;
  629.    }
  630.  
  631.    static void sort(ClassDeclaration[] var0) {
  632.       boolean var1;
  633.       do {
  634.          var1 = true;
  635.  
  636.          for(int var2 = var0.length - 1; var2 > 0; --var2) {
  637.             if (compare(var0[var2 - 1], var0[var2]) > 0) {
  638.                ClassDeclaration var3 = var0[var2];
  639.                var0[var2] = var0[var2 - 1];
  640.                var0[var2 - 1] = var3;
  641.                var1 = false;
  642.             }
  643.          }
  644.       } while(!var1);
  645.  
  646.    }
  647.  
  648.    void genPackagesDocumentation(Vector var1) {
  649.       Vector var2 = new Vector();
  650.       Vector var3 = new Vector();
  651.       Enumeration var4 = var1.elements();
  652.  
  653.       while(var4.hasMoreElements()) {
  654.          String var5 = (String)var4.nextElement();
  655.          (var5.startsWith("java.") ? var2 : var3).addElement(var5);
  656.       }
  657.  
  658.       String[] var7 = null;
  659.       String[] var6 = null;
  660.       if (var2.size() > 0) {
  661.          var7 = new String[var2.size()];
  662.          var2.copyInto(var7);
  663.          sort(var7);
  664.       }
  665.  
  666.       if (var3.size() > 0) {
  667.          var6 = new String[var3.size()];
  668.          var3.copyInto(var6);
  669.          sort(var6);
  670.       }
  671.  
  672.       this.genPackagesDocumentation(var7, var6);
  673.    }
  674.  
  675.    abstract void genPackagesDocumentation(String[] var1, String[] var2);
  676.  
  677.    private Vector collectClasses() {
  678.       Vector var1 = new Vector();
  679.       Enumeration var2 = this.env.getClasses();
  680.  
  681.       while(var2.hasMoreElements()) {
  682.          var1.addElement(var2.nextElement());
  683.       }
  684.  
  685.       return var1;
  686.    }
  687.  
  688.    void genPackageDocumentation(Identifier var1) {
  689.       boolean var2;
  690.       do {
  691.          var2 = false;
  692.          Enumeration var3 = this.collectClasses().elements();
  693.  
  694.          while(var3.hasMoreElements()) {
  695.             ClassDeclaration var4 = (ClassDeclaration)var3.nextElement();
  696.             if (!var4.isDefined()) {
  697.                try {
  698.                   this.getClassDefinition(var4);
  699.                   var2 = true;
  700.                } catch (ClassNotFound var17) {
  701.                }
  702.             }
  703.          }
  704.       } while(var2);
  705.  
  706.       Vector var18 = this.collectClasses();
  707.       int var20 = 0;
  708.       int var21 = 0;
  709.       int var5 = 0;
  710.       int var6 = 0;
  711.       Enumeration var7 = var18.elements();
  712.  
  713.       while(var7.hasMoreElements()) {
  714.          ClassDeclaration var8 = (ClassDeclaration)var7.nextElement();
  715.  
  716.          try {
  717.             ClassDefinition var9 = this.getClassDefinition(var8);
  718.             if (this.shouldDocument(var8) && var8.getName().getQualifier().equals(var1)) {
  719.                if (var9.isInterface()) {
  720.                   ++var20;
  721.                } else if (this.isException(var8)) {
  722.                   ++var5;
  723.                } else if (this.isError(var8)) {
  724.                   ++var6;
  725.                } else {
  726.                   ++var21;
  727.                }
  728.             }
  729.          } catch (ClassNotFound var16) {
  730.          }
  731.       }
  732.  
  733.       ClassDeclaration[] var22 = new ClassDeclaration[var20];
  734.       ClassDeclaration[] var23 = new ClassDeclaration[var21];
  735.       ClassDeclaration[] var10 = new ClassDeclaration[var5];
  736.       ClassDeclaration[] var11 = new ClassDeclaration[var6];
  737.       Enumeration var12 = var18.elements();
  738.  
  739.       while(var12.hasMoreElements()) {
  740.          ClassDeclaration var13 = (ClassDeclaration)var12.nextElement();
  741.  
  742.          try {
  743.             ClassDefinition var14 = this.getClassDefinition(var13);
  744.             if (this.shouldDocument(var13) && var13.getName().getQualifier().equals(var1)) {
  745.                if (var14.isInterface()) {
  746.                   --var20;
  747.                   var22[var20] = var13;
  748.                } else if (this.isException(var13)) {
  749.                   --var5;
  750.                   var10[var5] = var13;
  751.                } else if (this.isError(var13)) {
  752.                   --var6;
  753.                   var11[var6] = var13;
  754.                } else {
  755.                   --var21;
  756.                   var23[var21] = var13;
  757.                }
  758.             }
  759.          } catch (ClassNotFound var15) {
  760.          }
  761.       }
  762.  
  763.       Object var19 = null;
  764.       this.genPackageDocumentation(var1, var22, var23, var10, var11);
  765.    }
  766.  
  767.    abstract void genPackageDocumentation(Identifier var1, ClassDeclaration[] var2, ClassDeclaration[] var3, ClassDeclaration[] var4, ClassDeclaration[] var5);
  768.  
  769.    abstract void genClassDocumentation(ClassDeclaration var1, ClassDeclaration var2, ClassDeclaration var3);
  770.  
  771.    abstract String classString(ClassDeclaration var1);
  772.  
  773.    static void sort(FieldDefinition[] var0) {
  774.       xsort(var0);
  775.    }
  776.  
  777.    static void sort(String[] var0) {
  778.       boolean var1;
  779.       do {
  780.          var1 = true;
  781.  
  782.          for(int var2 = var0.length - 1; var2 > 0; --var2) {
  783.             if (var0[var2 - 1].compareTo(var0[var2]) > 0) {
  784.                String var3 = var0[var2];
  785.                var0[var2] = var0[var2 - 1];
  786.                var0[var2 - 1] = var3;
  787.                var1 = false;
  788.             }
  789.          }
  790.       } while(!var1);
  791.  
  792.    }
  793.  
  794.    static String sortKey(FieldDefinition var0) {
  795.       ClassDefinition var1 = var0.getClassDefinition();
  796.       String var2 = (var1.getName().getName() + "." + var1.getName().getQualifier()).toLowerCase();
  797.       if (var0.isVariable()) {
  798.          return var0.getName().toString().toLowerCase() + " " + var2;
  799.       } else {
  800.          String var3 = getReferenceName(var0);
  801.          Type var4 = var0.getType();
  802.          return var4.typeString(var3, true, false).toLowerCase() + var2;
  803.       }
  804.    }
  805.  
  806.    static void xsort(FieldDefinition[] var0, String[] var1) {
  807.       xsort(var0, var1, 0, var0.length - 1);
  808.    }
  809.  
  810.    static void xsort(FieldDefinition[] var0) {
  811.       String[] var1 = new String[var0.length];
  812.       int var2 = var0.length;
  813.  
  814.       while(true) {
  815.          --var2;
  816.          if (var2 < 0) {
  817.             xsort(var0, var1, 0, var0.length - 1);
  818.             return;
  819.          }
  820.  
  821.          var1[var2] = sortKey(var0[var2]);
  822.       }
  823.    }
  824.  
  825.    private static void xsort(FieldDefinition[] var0, String[] var1, int var2, int var3) {
  826.       if (var2 < var3) {
  827.          String var4 = var1[var2];
  828.          int var5 = var2;
  829.          int var6 = var3;
  830.  
  831.          while(var5 < var6) {
  832.             while(var5 <= var3 && var1[var5].compareTo(var4) <= 0) {
  833.                ++var5;
  834.             }
  835.  
  836.             while(var6 >= var2 && var1[var6].compareTo(var4) > 0) {
  837.                --var6;
  838.             }
  839.  
  840.             if (var5 < var6) {
  841.                FieldDefinition var7 = var0[var5];
  842.                String var8 = var1[var5];
  843.                var0[var5] = var0[var6];
  844.                var0[var6] = var7;
  845.                var1[var5] = var1[var6];
  846.                var1[var6] = var8;
  847.             }
  848.          }
  849.  
  850.          FieldDefinition var10 = var0[var2];
  851.          String var9 = var1[var2];
  852.          var0[var2] = var0[var6];
  853.          var0[var6] = var10;
  854.          var1[var2] = var1[var6];
  855.          var1[var6] = var9;
  856.          xsort(var0, var1, var2, var6 - 1);
  857.          xsort(var0, var1, var6 + 1, var3);
  858.       }
  859.    }
  860.  
  861.    Hashtable createClassTree() {
  862.       Hashtable var1 = new Hashtable();
  863.       Enumeration var2 = this.env.getClasses();
  864.  
  865.       while(var2.hasMoreElements()) {
  866.          ClassDeclaration var3 = (ClassDeclaration)var2.nextElement();
  867.          if (this.shouldDocument(var3)) {
  868.             this.genClassTree(var3, var1);
  869.          }
  870.       }
  871.  
  872.       Enumeration var7 = var1.keys();
  873.  
  874.       while(var7.hasMoreElements()) {
  875.          ClassDeclaration var4 = (ClassDeclaration)var7.nextElement();
  876.          Vector var5 = (Vector)var1.get(var4);
  877.          if (var5.size() > 0) {
  878.             ClassDeclaration[] var6 = new ClassDeclaration[var5.size()];
  879.             var5.copyInto(var6);
  880.             sort(var6);
  881.             var1.put(var4, var6);
  882.          } else {
  883.             var1.remove(var4);
  884.          }
  885.       }
  886.  
  887.       return var1;
  888.    }
  889.  
  890.    private Vector genClassTree(ClassDeclaration var1, Hashtable var2) {
  891.       Vector var3 = (Vector)var2.get(var1);
  892.       if (var3 != null) {
  893.          return var3;
  894.       } else {
  895.          var3 = new Vector();
  896.          var2.put(var1, var3);
  897.  
  898.          try {
  899.             ClassDeclaration var4 = this.getClassDefinition(var1).getSuperClass();
  900.             if (var4 != null) {
  901.                Vector var5 = this.genClassTree(var4, var2);
  902.                var5.addElement(var1);
  903.             }
  904.          } catch (ClassNotFound var6) {
  905.          }
  906.  
  907.          return var3;
  908.       }
  909.    }
  910.  
  911.    abstract void genFieldIndex();
  912.  
  913.    void genClassTree() {
  914.       this.genClassTree(this.createClassTree(), this.env.getClassDeclaration(Type.tObject.getClassName()));
  915.    }
  916.  
  917.    abstract void genClassTree(Hashtable var1, ClassDeclaration var2);
  918.  
  919.    void parseSeeString(String var1, ClassDeclaration var2, Vector var3) {
  920.       var1 = var1.trim();
  921.       int var7 = 0;
  922.  
  923.       for(int var8 = 0; var8 < var1.length(); ++var8) {
  924.          char var9 = var1.charAt(var8);
  925.          switch (var9) {
  926.             case '\t':
  927.             case ' ':
  928.             case ',':
  929.                if (var7 <= 0) {
  930.                   System.out.println(Main.getText("doc.see_warning_extraneous_text", var1));
  931.                   var1 = var1.substring(0, var8);
  932.                }
  933.                break;
  934.             case '(':
  935.                ++var7;
  936.                break;
  937.             case ')':
  938.                --var7;
  939.          }
  940.       }
  941.  
  942.       int var17 = var1.indexOf(35);
  943.       String var5;
  944.       String var6;
  945.       if (var17 >= 0) {
  946.          var6 = var1.substring(var17 + 1);
  947.          var5 = var1.substring(0, var17);
  948.       } else if (var1.indexOf(40) >= 0) {
  949.          System.out.println(Main.getText("doc.see_warning_missing_sharp", var1));
  950.          var6 = var1;
  951.          var5 = "";
  952.       } else {
  953.          var6 = null;
  954.          var5 = var1;
  955.       }
  956.  
  957.       ClassDeclaration var4;
  958.       if (var5.length() > 0) {
  959.          Identifier var10 = Identifier.lookup(var5);
  960.  
  961.          try {
  962.             ClassDefinition var11 = this.getClassDefinition(var2);
  963.             var4 = this.getClassDeclaration(var11, var10);
  964.             if (var4.getName().isInner() && var6 == null) {
  965.                int var12 = var5.lastIndexOf(46);
  966.                if (var12 >= 0) {
  967.                   String var13 = new String(var5);
  968.                   var6 = var5.substring(var12 + 1);
  969.                   var5 = var5.substring(0, var12);
  970.                   System.out.print(Main.getText("doc.see_warning_Treating_reference", var13, var5, var6));
  971.                   var10 = Identifier.lookup(var5);
  972.                   var4 = this.getClassDeclaration(var11, var10);
  973.                }
  974.             }
  975.          } catch (ClassNotFound var15) {
  976.             var4 = this.env.getClassDeclaration(Identifier.lookup(var5));
  977.          }
  978.       } else {
  979.          var4 = var2;
  980.       }
  981.  
  982.       if (var6 == null) {
  983.          var3.addElement(var4);
  984.          var3.addElement((Object)null);
  985.          var3.addElement((Object)null);
  986.       } else {
  987.          var17 = var6.indexOf(40);
  988.          String var20 = var17 >= 0 ? var6.substring(0, var17) : var6;
  989.          Identifier var21 = Identifier.lookup(var20);
  990.  
  991.          try {
  992.             if (!var20.equals(var5)) {
  993.                FieldDefinition var22 = this.findVisibleField(var4, this.env, var21, var17 > 0);
  994.                if (var22 == null) {
  995.                   System.out.println(Main.getText("doc.see_warning_Can_not_find_field", var20, var4.toString()));
  996.                } else if (var22.getClassDeclaration() != var4) {
  997.                   System.out.println(Main.getText("doc.see_warning_Found_in_parent", var20, var22.getClassDeclaration().toString(), var4.toString()));
  998.                   var4 = var22.getClassDeclaration();
  999.                }
  1000.             }
  1001.          } catch (ClassNotFound var14) {
  1002.             System.out.println(Main.getText("doc.see_warning_Can_not_find", var4.toString()));
  1003.          }
  1004.  
  1005.          var3.addElement(var4);
  1006.          var3.addElement(var20);
  1007.          var3.addElement(var6);
  1008.       }
  1009.    }
  1010.  
  1011.    FieldDefinition findVisibleField(ClassDeclaration var1, Environment var2, Identifier var3, boolean var4) throws ClassNotFound {
  1012.       ClassDefinition var5 = this.getClassDefinition(var1);
  1013.  
  1014.       for(FieldDefinition var6 = var5.getFirstMatch(var3); var6 != null; var6 = var6.getNextMatch()) {
  1015.          if (shouldDocument(var6) && (!var4 || var6.isMethod())) {
  1016.             return var6;
  1017.          }
  1018.       }
  1019.  
  1020.       ClassDeclaration var7 = var5.getSuperClass();
  1021.       if (var7 == null) {
  1022.          return null;
  1023.       } else {
  1024.          return this.findVisibleField(var7, var2, var3, var4);
  1025.       }
  1026.    }
  1027. }
  1028.