home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 139 / dpcs0999.iso / Web / CFserver / data1.cab / Java / netscape / util / ASCIIArchiveLoader.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-04-12  |  14.7 KB  |  868 lines
  1. package netscape.util;
  2.  
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStream;
  6.  
  7. class ASCIIArchiveLoader {
  8.    static final String classTablesKey = "classTables";
  9.    static final String fieldNamesKey = "fieldNames";
  10.    static final String fieldTypesKey = "fieldTypes";
  11.    static final String classNamesKey = "classNames";
  12.    static final String classVersionsKey = "classVersions";
  13.    static final String instancesKey = "instances";
  14.    static final String rootInstancesKey = "rootInstances";
  15.    static final String archiveVersionKey = "archiveVersion";
  16.    Archive archive;
  17.    Hashtable archiveDict;
  18.    IdHashtable idForName;
  19.    String[] nameForId;
  20.    Hashtable baseNameForTable;
  21.    static byte[] hexChar = new byte[]{48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102};
  22.  
  23.    ASCIIArchiveLoader(Archive var1) {
  24.       this.archive = var1;
  25.    }
  26.  
  27.    void readASCII(InputStream var1) throws CodingException, DeserializationException, IOException {
  28.       Deserializer var2 = null;
  29.       if (var1 instanceof Deserializer) {
  30.          var2 = (Deserializer)var1;
  31.       }
  32.  
  33.       this.idForName = new IdHashtable(true);
  34.       if (var2 == null) {
  35.          var2 = new Deserializer(var1);
  36.       }
  37.  
  38.       this.archiveDict = (Hashtable)var2.readObject();
  39.       String var3 = (String)this.archiveDict.get("archiveVersion");
  40.       if (var3 == null) {
  41.          throw new IOException("Missing archiveVersion");
  42.       } else {
  43.          this.archive.version = Integer.parseInt(var3);
  44.          if (this.archive.version != 1) {
  45.             throw new IOException("Unknown archiveVersion " + this.archive.version);
  46.          } else {
  47.             this.loadClassInfo();
  48.             this.loadInstanceData();
  49.             this.loadRoots();
  50.          }
  51.       }
  52.    }
  53.  
  54.    void loadClassInfo() throws CodingException {
  55.       Hashtable var1 = (Hashtable)this.archiveDict.get("classTables");
  56.       if (var1 != null) {
  57.          Enumeration var3 = var1.keys();
  58.  
  59.          while(var3.hasMoreElements()) {
  60.             String var4 = (String)var3.nextElement();
  61.             Hashtable var2 = (Hashtable)var1.get(var4);
  62.             ClassInfo var10 = new ClassInfo(var4);
  63.             Object[] var7 = var2.get("classNames");
  64.             Object[] var8 = var2.get("classVersions");
  65.  
  66.             for(int var11 = 0; var11 < var7.length; ++var11) {
  67.                int var12 = Integer.parseInt((String)var8[var11]);
  68.                var10.addClass((String)var7[var11], var12);
  69.             }
  70.  
  71.             Object[] var5 = var2.get("fieldNames");
  72.             Object[] var6 = var2.get("fieldTypes");
  73.  
  74.             for(int var13 = 0; var13 < var5.length; ++var13) {
  75.                var10.addField((String)var5[var13], typeForName((String)var6[var13]));
  76.             }
  77.  
  78.             ClassTable var9 = new ClassTable(this.archive, var10);
  79.             this.archive.addClassTable(var9);
  80.          }
  81.  
  82.       }
  83.    }
  84.  
  85.    static byte typeForName(String var0) throws CodingException {
  86.       int var1 = var0.length();
  87.       if (var1 <= 0) {
  88.          throw new CodingException("unknown type name: " + var0);
  89.       } else {
  90.          switch (var0.charAt(0)) {
  91.             case 'b':
  92.                if (var0.equals("boolean")) {
  93.                   return 0;
  94.                }
  95.  
  96.                if (var0.equals("boolean[]")) {
  97.                   return 1;
  98.                }
  99.  
  100.                if (var0.equals("byte")) {
  101.                   return 4;
  102.                }
  103.  
  104.                if (var0.equals("byte[]")) {
  105.                   return 5;
  106.                }
  107.                break;
  108.             case 'c':
  109.                if (var0.equals("char")) {
  110.                   return 2;
  111.                }
  112.  
  113.                if (var0.equals("char[]")) {
  114.                   return 3;
  115.                }
  116.                break;
  117.             case 'd':
  118.                if (var0.equals("double")) {
  119.                   return 14;
  120.                }
  121.  
  122.                if (var0.equals("double[]")) {
  123.                   return 15;
  124.                }
  125.                break;
  126.             case 'f':
  127.                if (var0.equals("float")) {
  128.                   return 12;
  129.                }
  130.  
  131.                if (var0.equals("float[]")) {
  132.                   return 13;
  133.                }
  134.                break;
  135.             case 'i':
  136.                if (var0.equals("int")) {
  137.                   return 8;
  138.                }
  139.  
  140.                if (var0.equals("int[]")) {
  141.                   return 9;
  142.                }
  143.                break;
  144.             case 'j':
  145.                if (var1 == 16) {
  146.                   if (var0.equals("java.lang.String")) {
  147.                      return 16;
  148.                   }
  149.  
  150.                   if (var0.equals("java.lang.Object")) {
  151.                      return 18;
  152.                   }
  153.                } else if (var1 == 18) {
  154.                   if (var0.equals("java.lang.String[]")) {
  155.                      return 17;
  156.                   }
  157.  
  158.                   if (var0.equals("java.lang.Object[]")) {
  159.                      return 19;
  160.                   }
  161.                }
  162.                break;
  163.             case 'l':
  164.                if (var0.equals("long")) {
  165.                   return 10;
  166.                }
  167.  
  168.                if (var0.equals("long[]")) {
  169.                   return 11;
  170.                }
  171.                break;
  172.             case 's':
  173.                if (var0.equals("short")) {
  174.                   return 6;
  175.                }
  176.  
  177.                if (var0.equals("short[]")) {
  178.                   return 7;
  179.                }
  180.          }
  181.  
  182.          throw new CodingException("unknown type name: " + var0);
  183.       }
  184.    }
  185.  
  186.    void loadInstanceData() throws CodingException {
  187.       Hashtable var3 = (Hashtable)this.archiveDict.get("classTables");
  188.       if (var3 != null) {
  189.          Enumeration var2 = var3.keys();
  190.  
  191.          while(var2.hasMoreElements()) {
  192.             String var1 = (String)var2.nextElement();
  193.             Hashtable var4 = (Hashtable)var3.get(var1);
  194.             this.loadRowMapping(var1, var4);
  195.          }
  196.  
  197.          var2 = var3.keys();
  198.  
  199.          while(var2.hasMoreElements()) {
  200.             String var5 = (String)var2.nextElement();
  201.             Hashtable var7 = (Hashtable)var3.get(var5);
  202.             this.loadRowData(var5, var7);
  203.          }
  204.  
  205.       }
  206.    }
  207.  
  208.    void loadRowMapping(String var1, Hashtable var2) throws CodingException {
  209.       Hashtable var4 = (Hashtable)var2.get("instances");
  210.       if (var4 != null) {
  211.          Enumeration var7 = var4.keys();
  212.  
  213.          while(var7.hasMoreElements()) {
  214.             String var8 = (String)var7.nextElement();
  215.             Hashtable var5 = (Hashtable)var4.get(var8);
  216.             if (this.idForName.get(var8) != 0) {
  217.                throw new CodingException("duplicate instance name: " + var8);
  218.             }
  219.  
  220.             ClassTable var6 = this.archive.classTableForName(var1);
  221.             if (var6 == null) {
  222.                throw new CodingException("bad class name for instance: " + var8);
  223.             }
  224.  
  225.             int var3 = var6.newIdentifier();
  226.             this.idForName.putKnownAbsent(var8, var3);
  227.          }
  228.  
  229.       }
  230.    }
  231.  
  232.    void loadRowData(String var1, Hashtable var2) throws CodingException {
  233.       Hashtable var8 = (Hashtable)var2.get("instances");
  234.       if (var8 != null) {
  235.          Enumeration var5 = var8.keys();
  236.  
  237.          while(var5.hasMoreElements()) {
  238.             String var6 = (String)var5.nextElement();
  239.             int var3 = this.idForName.get(var6);
  240.             ClassTable var7 = this.archive.tableForId[var3];
  241.             int var4 = this.archive.rowForId[var3];
  242.             Hashtable var9 = (Hashtable)var8.get(var6);
  243.             this.loadRow(var7, var4, var9);
  244.          }
  245.  
  246.       }
  247.    }
  248.  
  249.    void loadRow(ClassTable var1, int var2, Hashtable var3) throws CodingException {
  250.       for(int var4 = 0; var4 < var1.fieldCount; ++var4) {
  251.          Object var5 = var3.get(var1.fieldNames[var4]);
  252.          if (var5 != null) {
  253.             this.setColumnFromValue(var1, var2, var4, var5);
  254.          }
  255.       }
  256.  
  257.    }
  258.  
  259.    void setColumnFromValue(ClassTable var1, int var2, int var3, Object var4) throws CodingException {
  260.       Object var15 = null;
  261.       Object var16 = null;
  262.       if (var4 instanceof String) {
  263.          String var42 = (String)var4;
  264.          switch (var1.fieldTypes[var3]) {
  265.             case 0:
  266.                if (var42.equalsIgnoreCase("true")) {
  267.                   var1.setBooleanAt(var2, var3, true);
  268.                   return;
  269.                } else {
  270.                   if (var42.equalsIgnoreCase("false")) {
  271.                      var1.setBooleanAt(var2, var3, false);
  272.                      return;
  273.                   }
  274.  
  275.                   throw new CodingException("Invalid boolean value");
  276.                }
  277.             case 2:
  278.                var1.setCharAt(var2, var3, var42.charAt(0));
  279.                return;
  280.             case 4:
  281.                var1.setByteAt(var2, var3, (byte)Integer.parseInt(var42));
  282.                return;
  283.             case 5:
  284.                var1.setByteArrayAt(var2, var3, this.bytesFromString(var42));
  285.                return;
  286.             case 6:
  287.                var1.setShortAt(var2, var3, (short)Integer.parseInt(var42));
  288.                return;
  289.             case 8:
  290.                var1.setIntAt(var2, var3, Integer.parseInt(var42));
  291.                return;
  292.             case 10:
  293.                var1.setLongAt(var2, var3, Long.parseLong(var42));
  294.                return;
  295.             case 12:
  296.                var1.setFloatAt(var2, var3, Float.valueOf(var42));
  297.                return;
  298.             case 14:
  299.                var1.setDoubleAt(var2, var3, Double.valueOf(var42));
  300.                return;
  301.             case 16:
  302.                var1.setStringAt(var2, var3, var42);
  303.                return;
  304.             case 18:
  305.                var1.setIdentifierAt(var2, var3, this.idForName.get(var42));
  306.                return;
  307.             default:
  308.                throw new CodingException("Invalid value " + var42);
  309.          }
  310.       } else if (var4 instanceof Object[]) {
  311.          var16 = var4;
  312.          switch (var1.fieldTypes[var3]) {
  313.             case 1:
  314.                int var32 = ((Object[])var16).length;
  315.                boolean[] var7 = new boolean[var32];
  316.  
  317.                for(int var24 = 0; var24 < var32; ++var24) {
  318.                   String var41 = (String)((Object[])var16)[var24];
  319.                   if (var41.equalsIgnoreCase("true")) {
  320.                      var7[var24] = true;
  321.                   } else {
  322.                      if (!var41.equalsIgnoreCase("false")) {
  323.                         throw new CodingException("Invalid boolean value");
  324.                      }
  325.  
  326.                      var7[var24] = false;
  327.                   }
  328.                }
  329.  
  330.                var1.setBooleanArrayAt(var2, var3, var7);
  331.                return;
  332.             case 3:
  333.                int var31 = ((Object[])var16).length;
  334.                char[] var8 = new char[var31];
  335.  
  336.                for(int var23 = 0; var23 < var31; ++var23) {
  337.                   String var40 = (String)((Object[])var16)[var23];
  338.                   var8[var23] = var40.charAt(0);
  339.                }
  340.  
  341.                var1.setCharArrayAt(var2, var3, var8);
  342.                return;
  343.             case 7:
  344.                int var30 = ((Object[])var16).length;
  345.                short[] var9 = new short[var30];
  346.  
  347.                for(int var22 = 0; var22 < var30; ++var22) {
  348.                   String var39 = (String)((Object[])var16)[var22];
  349.                   var9[var22] = (short)Integer.parseInt(var39);
  350.                }
  351.  
  352.                var1.setShortArrayAt(var2, var3, var9);
  353.                return;
  354.             case 9:
  355.                int var29 = ((Object[])var16).length;
  356.                int[] var33 = new int[var29];
  357.  
  358.                for(int var21 = 0; var21 < var29; ++var21) {
  359.                   String var38 = (String)((Object[])var16)[var21];
  360.                   var33[var21] = Integer.parseInt(var38);
  361.                }
  362.  
  363.                var1.setIntArrayAt(var2, var3, var33);
  364.                return;
  365.             case 11:
  366.                int var28 = ((Object[])var16).length;
  367.                long[] var11 = new long[var28];
  368.  
  369.                for(int var20 = 0; var20 < var28; ++var20) {
  370.                   String var37 = (String)((Object[])var16)[var20];
  371.                   var11[var20] = Long.parseLong(var37);
  372.                }
  373.  
  374.                var1.setLongArrayAt(var2, var3, var11);
  375.                return;
  376.             case 13:
  377.                int var27 = ((Object[])var16).length;
  378.                float[] var12 = new float[var27];
  379.  
  380.                for(int var19 = 0; var19 < var27; ++var19) {
  381.                   String var36 = (String)((Object[])var16)[var19];
  382.                   var12[var19] = Float.valueOf(var36);
  383.                }
  384.  
  385.                var1.setFloatArrayAt(var2, var3, var12);
  386.                return;
  387.             case 15:
  388.                int var26 = ((Object[])var16).length;
  389.                double[] var13 = new double[var26];
  390.  
  391.                for(int var18 = 0; var18 < var26; ++var18) {
  392.                   String var35 = (String)((Object[])var16)[var18];
  393.                   var13[var18] = Double.valueOf(var35);
  394.                }
  395.  
  396.                var1.setDoubleArrayAt(var2, var3, var13);
  397.                return;
  398.             case 17:
  399.                int var25 = ((Object[])var16).length;
  400.                String[] var14 = new String[var25];
  401.  
  402.                for(int var17 = 0; var17 < var25; ++var17) {
  403.                   var14[var17] = (String)((Object[])var16)[var17];
  404.                }
  405.  
  406.                var1.setStringArrayAt(var2, var3, var14);
  407.                return;
  408.             case 19:
  409.                int var6 = ((Object[])var16).length;
  410.                int[] var10 = new int[var6];
  411.  
  412.                for(int var5 = 0; var5 < var6; ++var5) {
  413.                   String var34 = (String)((Object[])var16)[var5];
  414.                   if (var34 != null) {
  415.                      var10[var5] = this.idForName.get(var34);
  416.                   }
  417.                }
  418.  
  419.                var1.setIdentifierArrayAt(var2, var3, var10);
  420.                return;
  421.             default:
  422.                throw new CodingException("Invalid value" + var15);
  423.          }
  424.       }
  425.    }
  426.  
  427.    byte[] bytesFromString(String var1) {
  428.       if (var1 == null) {
  429.          return null;
  430.       } else if (var1.equals("")) {
  431.          return new byte[0];
  432.       } else {
  433.          int var3 = var1.length();
  434.          byte[] var7 = new byte[var3 / 2 + 1];
  435.          int var2 = 0;
  436.          int var5 = 0;
  437.  
  438.          while(var2 < var3) {
  439.             while(var2 < var3) {
  440.                char var6 = var1.charAt(var2++);
  441.                if (!Character.isSpace(var6)) {
  442.                   if (var2 >= var3) {
  443.                      throw new NumberFormatException("bad byte string");
  444.                   }
  445.  
  446.                   int var4 = this.nibbleForHexChar(var6);
  447.                   var6 = var1.charAt(var2++);
  448.                   var7[var5++] = (byte)((var4 << 4) + this.nibbleForHexChar(var6));
  449.                }
  450.             }
  451.          }
  452.  
  453.          byte[] var8 = new byte[var5];
  454.          System.arraycopy(var7, 0, var8, 0, var5);
  455.          return var8;
  456.       }
  457.    }
  458.  
  459.    int nibbleForHexChar(char var1) {
  460.       if (var1 >= '0' && var1 <= '9') {
  461.          return var1 - 48;
  462.       } else if (var1 >= 'a' && var1 <= 'f') {
  463.          return var1 - 97 + 10;
  464.       } else if (var1 >= 'A' && var1 <= 'F') {
  465.          return var1 - 65 + 10;
  466.       } else {
  467.          throw new NumberFormatException("bad byte string");
  468.       }
  469.    }
  470.  
  471.    void loadRoots() throws CodingException {
  472.       Object[] var3 = this.archiveDict.get("rootInstances");
  473.       if (var3 != null && var3.length != 0) {
  474.          for(int var1 = 0; var1 < var3.length; ++var1) {
  475.             String var4 = (String)var3[var1];
  476.             int var2;
  477.             if (var4 != null && !var4.equals("")) {
  478.                var2 = this.idForName.get(var4);
  479.             } else {
  480.                var2 = 0;
  481.             }
  482.  
  483.             if (var2 == 0) {
  484.                throw new CodingException("unknown root instance " + var4);
  485.             }
  486.  
  487.             this.archive.addRootIdentifier(var2);
  488.          }
  489.  
  490.       }
  491.    }
  492.  
  493.    void writeASCII(OutputStream var1, boolean var2) throws IOException {
  494.       this.nameForId = new String[this.archive.idCount];
  495.       this.baseNameForTable = new Hashtable();
  496.       this.archiveDict = new Hashtable();
  497.       String var4 = String.valueOf(1);
  498.       this.archiveDict.put("archiveVersion", var4);
  499.       this.saveClassInfo();
  500.       this.saveInstanceData();
  501.       this.saveRoots();
  502.       Object var3;
  503.       if (var2) {
  504.          var3 = new FormattingSerializer(var1);
  505.       } else {
  506.          var3 = new Serializer(var1);
  507.       }
  508.  
  509.       ((Serializer)var3).writeObject(this.archiveDict);
  510.       ((Serializer)var3).flush();
  511.    }
  512.  
  513.    String nameForId(int var1) {
  514.       String var2 = this.nameForId[var1];
  515.       if (var2 != null) {
  516.          return var2;
  517.       } else {
  518.          ClassTable var5 = this.archive.tableForId[var1];
  519.          if (var5 == null) {
  520.             return null;
  521.          } else {
  522.             String var3 = (String)this.baseNameForTable.get(var5);
  523.             if (var3 == null) {
  524.                var3 = var5.className();
  525.                int var6 = var3.lastIndexOf(46);
  526.                if (var6 > 0 && var6 < var3.length() - 1 && var3.charAt(0) != '[') {
  527.                   var3 = var3.substring(var6 + 1, var3.length());
  528.                }
  529.  
  530.                var3 = var3 + "-";
  531.                if (this.baseNameForTable.get(var3) != null) {
  532.                   var3 = var5.className() + "-";
  533.  
  534.                   for(int var7 = 0; this.baseNameForTable.get(var3) != null; ++var7) {
  535.                      var3 = var5.className() + "-" + var7 + "-";
  536.                   }
  537.                }
  538.  
  539.                this.baseNameForTable.put(var5, var3);
  540.             }
  541.  
  542.             int var10 = this.decimalDigitCount(var5.rowCount());
  543.             String var4 = this.decimalString(this.archive.rowForId[var1], var10);
  544.             var2 = var3 + var4;
  545.             this.nameForId[var1] = var2;
  546.             return var2;
  547.          }
  548.       }
  549.    }
  550.  
  551.    int decimalDigitCount(int var1) {
  552.       int var2;
  553.       for(var2 = 0; var1 > 0; var1 /= 10) {
  554.          ++var2;
  555.       }
  556.  
  557.       return var2;
  558.    }
  559.  
  560.    String decimalString(int var1, int var2) {
  561.       char[] var4 = new char[var2];
  562.  
  563.       for(int var3 = 0; var3 < var2; ++var3) {
  564.          var4[var3] = '0';
  565.       }
  566.  
  567.       for(int var5 = var2; var1 > 0 && var5 > 0; var1 /= 10) {
  568.          --var5;
  569.          var4[var5] = (char)(var1 % 10 + 48);
  570.       }
  571.  
  572.       return new String(var4);
  573.    }
  574.  
  575.    void saveClassInfo() {
  576.       Hashtable var1 = new Hashtable();
  577.       Enumeration var3 = this.archive.classTables.elements();
  578.  
  579.       while(var3.hasMoreElements()) {
  580.          ClassTable var4 = (ClassTable)var3.nextElement();
  581.          Hashtable var2 = this.dictionaryForTable(var4);
  582.          var1.put(var4.className(), var2);
  583.       }
  584.  
  585.       this.archiveDict.put("classTables", var1);
  586.    }
  587.  
  588.    Hashtable dictionaryForTable(ClassTable var1) {
  589.       Hashtable var3 = new Hashtable(5);
  590.       String[] var4 = new String[var1.fieldCount];
  591.  
  592.       for(int var2 = 0; var2 < var1.fieldCount; ++var2) {
  593.          var4[var2] = this.nameForType(var1.fieldTypes[var2]);
  594.       }
  595.  
  596.       var3.put("fieldNames", var1.fieldNames);
  597.       var3.put("fieldTypes", var4);
  598.       String[] var5 = new String[var1.classCount];
  599.  
  600.       for(int var6 = 0; var6 < var1.classCount; ++var6) {
  601.          var5[var6] = String.valueOf(var1.classVersions[var6]);
  602.       }
  603.  
  604.       var3.put("classNames", var1.classNames);
  605.       var3.put("classVersions", var5);
  606.       return var3;
  607.    }
  608.  
  609.    String nameForType(int var1) {
  610.       switch (var1) {
  611.          case 0:
  612.             return "boolean";
  613.          case 1:
  614.             return "boolean[]";
  615.          case 2:
  616.             return "char";
  617.          case 3:
  618.             return "char[]";
  619.          case 4:
  620.             return "byte";
  621.          case 5:
  622.             return "byte[]";
  623.          case 6:
  624.             return "short";
  625.          case 7:
  626.             return "short[]";
  627.          case 8:
  628.             return "int";
  629.          case 9:
  630.             return "int[]";
  631.          case 10:
  632.             return "long";
  633.          case 11:
  634.             return "long[]";
  635.          case 12:
  636.             return "float";
  637.          case 13:
  638.             return "float[]";
  639.          case 14:
  640.             return "double";
  641.          case 15:
  642.             return "double[]";
  643.          case 16:
  644.             return "java.lang.String";
  645.          case 17:
  646.             return "java.lang.String[]";
  647.          case 18:
  648.             return "java.lang.Object";
  649.          case 19:
  650.             return "java.lang.Object[]";
  651.          default:
  652.             throw new IllegalArgumentException("Unknown field type: " + var1);
  653.       }
  654.    }
  655.  
  656.    void saveInstanceData() {
  657.       Hashtable var5 = (Hashtable)this.archiveDict.get("classTables");
  658.  
  659.       for(int var1 = 1; var1 < this.archive.idCount; ++var1) {
  660.          ClassTable var7 = this.archive.tableForId[var1];
  661.          int var2 = this.archive.rowForId[var1];
  662.          Hashtable var4 = this.dictionaryForInstance(var7, var2);
  663.          Hashtable var6 = (Hashtable)var5.get(var7.className);
  664.          Hashtable var3 = (Hashtable)var6.get("instances");
  665.          if (var3 == null) {
  666.             var3 = new Hashtable();
  667.             var6.put("instances", var3);
  668.          }
  669.  
  670.          var3.put(this.nameForId(var1), var4);
  671.       }
  672.  
  673.    }
  674.  
  675.    Hashtable dictionaryForInstance(ClassTable var1, int var2) {
  676.       Hashtable var4 = new Hashtable(2 * var1.fieldCount);
  677.  
  678.       for(int var3 = 0; var3 < var1.fieldCount; ++var3) {
  679.          Object var5 = this.valueForField(var1, var2, var3);
  680.          if (var5 != null) {
  681.             var4.put(var1.fieldNames[var3], var5);
  682.          }
  683.       }
  684.  
  685.       return var4;
  686.    }
  687.  
  688.    Object valueForField(ClassTable var1, int var2, int var3) {
  689.       switch (var1.fieldTypes[var3]) {
  690.          case 0:
  691.             return String.valueOf(var1.booleanAt(var2, var3));
  692.          case 1:
  693.             boolean[] var6 = var1.booleanArrayAt(var2, var3);
  694.             if (var6 == null) {
  695.                return null;
  696.             }
  697.  
  698.             int var27 = var6.length;
  699.             String[] var35 = new String[var27];
  700.  
  701.             for(int var20 = 0; var20 < var27; ++var20) {
  702.                var35[var20] = String.valueOf(var6[var20]);
  703.             }
  704.  
  705.             return var35;
  706.          case 2:
  707.             return String.valueOf(var1.charAt(var2, var3));
  708.          case 3:
  709.             char[] var7 = var1.charArrayAt(var2, var3);
  710.             if (var7 == null) {
  711.                return null;
  712.             }
  713.  
  714.             int var26 = var7.length;
  715.             String[] var34 = new String[var26];
  716.  
  717.             for(int var19 = 0; var19 < var26; ++var19) {
  718.                var34[var19] = String.valueOf(var7[var19]);
  719.             }
  720.  
  721.             return var34;
  722.          case 4:
  723.             return String.valueOf(var1.byteAt(var2, var3) & 255);
  724.          case 5:
  725.             return bytesString(var1.byteArrayAt(var2, var3));
  726.          case 6:
  727.             return String.valueOf(var1.shortAt(var2, var3));
  728.          case 7:
  729.             short[] var8 = var1.shortArrayAt(var2, var3);
  730.             if (var8 == null) {
  731.                return null;
  732.             }
  733.  
  734.             int var25 = var8.length;
  735.             String[] var33 = new String[var25];
  736.  
  737.             for(int var18 = 0; var18 < var25; ++var18) {
  738.                var33[var18] = String.valueOf(var8[var18]);
  739.             }
  740.  
  741.             return var33;
  742.          case 8:
  743.             return String.valueOf(var1.intAt(var2, var3));
  744.          case 9:
  745.             int[] var28 = var1.intArrayAt(var2, var3);
  746.             if (var28 == null) {
  747.                return null;
  748.             }
  749.  
  750.             int var24 = var28.length;
  751.             String[] var32 = new String[var24];
  752.  
  753.             for(int var17 = 0; var17 < var24; ++var17) {
  754.                var32[var17] = String.valueOf(var28[var17]);
  755.             }
  756.  
  757.             return var32;
  758.          case 10:
  759.             return String.valueOf(var1.longAt(var2, var3));
  760.          case 11:
  761.             long[] var10 = var1.longArrayAt(var2, var3);
  762.             if (var10 == null) {
  763.                return null;
  764.             }
  765.  
  766.             int var23 = var10.length;
  767.             String[] var31 = new String[var23];
  768.  
  769.             for(int var16 = 0; var16 < var23; ++var16) {
  770.                var31[var16] = String.valueOf(var10[var16]);
  771.             }
  772.  
  773.             return var31;
  774.          case 12:
  775.             return String.valueOf(var1.floatAt(var2, var3));
  776.          case 13:
  777.             float[] var11 = var1.floatArrayAt(var2, var3);
  778.             if (var11 == null) {
  779.                return null;
  780.             }
  781.  
  782.             int var22 = var11.length;
  783.             String[] var30 = new String[var22];
  784.  
  785.             for(int var15 = 0; var15 < var22; ++var15) {
  786.                var30[var15] = String.valueOf(var11[var15]);
  787.             }
  788.  
  789.             return var30;
  790.          case 14:
  791.             return String.valueOf(var1.doubleAt(var2, var3));
  792.          case 15:
  793.             double[] var12 = var1.doubleArrayAt(var2, var3);
  794.             if (var12 == null) {
  795.                return null;
  796.             }
  797.  
  798.             int var21 = var12.length;
  799.             String[] var29 = new String[var21];
  800.  
  801.             for(int var14 = 0; var14 < var21; ++var14) {
  802.                var29[var14] = String.valueOf(var12[var14]);
  803.             }
  804.  
  805.             return var29;
  806.          case 16:
  807.             return var1.stringAt(var2, var3);
  808.          case 17:
  809.             return var1.stringArrayAt(var2, var3);
  810.          case 18:
  811.             return this.nameForId(var1.identifierAt(var2, var3));
  812.          case 19:
  813.             int[] var9 = var1.identifierArrayAt(var2, var3);
  814.             if (var9 == null) {
  815.                return null;
  816.             }
  817.  
  818.             int var5 = var9.length;
  819.             String[] var13 = new String[var5];
  820.  
  821.             for(int var4 = 0; var4 < var5; ++var4) {
  822.                var13[var4] = this.nameForId(var9[var4]);
  823.             }
  824.  
  825.             return var13;
  826.          default:
  827.             throw new InconsistencyException("Unknown field type: " + var1.fieldTypes[var3]);
  828.       }
  829.    }
  830.  
  831.    static String bytesString(byte[] var0) {
  832.       if (var0 == null) {
  833.          return null;
  834.       } else if (var0.length == 0) {
  835.          return "";
  836.       } else {
  837.          int var2 = var0.length;
  838.          byte[] var5 = new byte[2 * var2 + var2 / 4 + 1];
  839.          int var3 = 0;
  840.  
  841.          for(int var1 = 0; var1 < var2; ++var1) {
  842.             byte var4 = var0[var1];
  843.             var5[var3++] = hexChar[var4 >>> 4 & 15];
  844.             var5[var3++] = hexChar[var4 & 15];
  845.             if ((var1 + 1) % 4 == 0) {
  846.                var5[var3++] = 32;
  847.             }
  848.          }
  849.  
  850.          if (var5[var3 - 1] == 32) {
  851.             --var3;
  852.          }
  853.  
  854.          return new String(var5, 0, 0, var3);
  855.       }
  856.    }
  857.  
  858.    void saveRoots() {
  859.       String[] var2 = new String[this.archive.rootCount];
  860.  
  861.       for(int var1 = 0; var1 < this.archive.rootCount; ++var1) {
  862.          var2[var1] = this.nameForId(this.archive.roots[var1]);
  863.       }
  864.  
  865.       this.archiveDict.put("rootInstances", var2);
  866.    }
  867. }
  868.