home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / xml4j.jar / com / ibm / xml / internal / DefaultElementDeclPool.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-08-30  |  11.5 KB  |  922 lines
  1. package com.ibm.xml.internal;
  2.  
  3. import com.ibm.xml.framework.AttDef;
  4. import com.ibm.xml.framework.Attr;
  5. import com.ibm.xml.framework.AttrPool;
  6. import com.ibm.xml.framework.ContentModel;
  7. import com.ibm.xml.framework.ContentSpecNode;
  8. import com.ibm.xml.framework.ElementDecl;
  9. import com.ibm.xml.framework.ElementDeclPool;
  10. import com.ibm.xml.framework.ParserState;
  11. import com.ibm.xml.framework.StringPool;
  12. import com.ibm.xml.framework.XMLErrorHandler;
  13. import com.ibm.xml.framework.XMLValidationHandler;
  14. import java.util.Enumeration;
  15. import java.util.Hashtable;
  16.  
  17. public final class DefaultElementDeclPool implements ElementDeclPool {
  18.    private static final int CHUNK_SHIFT = 5;
  19.    private static final int CHUNK_SIZE = 32;
  20.    private static final int CHUNK_MASK = 31;
  21.    private static final int INITIAL_CHUNK_COUNT = 32;
  22.    private ParserState fParserState;
  23.    private StringPool fStringPool;
  24.    private AttrPool fAttrPool;
  25.    private XMLErrorHandler fErrorHandler;
  26.    private XMLValidationHandler fValidationHandler;
  27.    private int fRootElement = -1;
  28.    private Attr fAttr = new Attr();
  29.    private int fElementCount;
  30.    private int[][] fElementName = new int[32][];
  31.    private byte[][] fContentSpecType = new byte[32][];
  32.    private int[][] fContentSpec = new int[32][];
  33.    private ContentModel[][] fContentModel = new ContentModel[32][];
  34.    private int[][] fAttlistHead = new int[32][];
  35.    private int[][] fAttlistTail = new int[32][];
  36.    private int fNodeCount;
  37.    private byte[][] fNodeType = new byte[32][];
  38.    private int[][] fNodeValue = new int[32][];
  39.    private int fAttDefCount;
  40.    private int[][] fAttName = new int[32][];
  41.    private byte[][] fAttType = new byte[32][];
  42.    private int[][] fEnumeration = new int[32][];
  43.    private byte[][] fAttDefaultType = new byte[32][];
  44.    private int[][] fAttValue = new int[32][];
  45.    private int[][] fNextAttDef = new int[32][];
  46.    private static final int INITIAL_BUCKET_SIZE = 4;
  47.    private static final int HASHTABLE_SIZE = 128;
  48.    private int[][] fElementNameHashtable = new int[128][];
  49.    private int fXMLSpace = -1;
  50.    private int fDefault = -1;
  51.    private int fPreserve = -1;
  52.    private Hashtable fIdDefs;
  53.    private Hashtable fIdRefs;
  54.    private Object fNullValue;
  55.    private int[] localpartcache = new int[8];
  56.    private int[] nsnamecache = new int[8];
  57.  
  58.    public DefaultElementDeclPool(ParserState var1) {
  59.       this.fParserState = var1;
  60.       this.fStringPool = var1.cacheStringPool();
  61.       this.fAttrPool = var1.cacheAttrPool();
  62.       this.fErrorHandler = var1.getErrorHandler();
  63.       this.fValidationHandler = var1.getValidationHandler();
  64.    }
  65.  
  66.    public void reset(ParserState var1) {
  67.       this.fParserState = var1;
  68.       this.fStringPool = var1.cacheStringPool();
  69.       this.fAttrPool = var1.cacheAttrPool();
  70.       this.fErrorHandler = var1.getErrorHandler();
  71.       this.fValidationHandler = var1.getValidationHandler();
  72.       int var2 = 0;
  73.       int var3 = 0;
  74.  
  75.       for(int var4 = 0; var4 < this.fElementCount; ++var4) {
  76.          this.fContentModel[var2][var3] = null;
  77.          ++var3;
  78.          if (var3 == 32) {
  79.             ++var2;
  80.             var3 = 0;
  81.          }
  82.       }
  83.  
  84.       for(int var5 = 0; var5 < 128; ++var5) {
  85.          this.fElementNameHashtable[var5] = null;
  86.       }
  87.  
  88.       this.fRootElement = -1;
  89.       this.fElementCount = 0;
  90.       this.fNodeCount = 0;
  91.       this.fAttDefCount = 0;
  92.       this.fXMLSpace = -1;
  93.       this.fDefault = -1;
  94.       this.fPreserve = -1;
  95.       if (this.fIdDefs != null) {
  96.          this.fIdDefs.clear();
  97.       }
  98.  
  99.       if (this.fIdRefs != null) {
  100.          this.fIdRefs.clear();
  101.       }
  102.  
  103.    }
  104.  
  105.    public ElementDeclPool resetOrCopy(ParserState var1) {
  106.       return new DefaultElementDeclPool(var1);
  107.    }
  108.  
  109.    public void setRootElement(int var1) {
  110.       this.fRootElement = var1;
  111.    }
  112.  
  113.    public int getRootElement() {
  114.       return this.fRootElement;
  115.    }
  116.  
  117.    private boolean ensureElementCapacity(int var1) {
  118.       try {
  119.          if (this.fElementName[var1][0] != 0) {
  120.             return false;
  121.          }
  122.  
  123.          return true;
  124.       } catch (ArrayIndexOutOfBoundsException var5) {
  125.          byte[][] var2 = new byte[var1 * 2][];
  126.          System.arraycopy(this.fContentSpecType, 0, var2, 0, var1);
  127.          this.fContentSpecType = var2;
  128.          int[][] var3 = new int[var1 * 2][];
  129.          System.arraycopy(this.fElementName, 0, var3, 0, var1);
  130.          this.fElementName = var3;
  131.          var3 = new int[var1 * 2][];
  132.          System.arraycopy(this.fContentSpec, 0, var3, 0, var1);
  133.          this.fContentSpec = var3;
  134.          ContentModel[][] var4 = new ContentModel[var1 * 2][];
  135.          System.arraycopy(this.fContentModel, 0, var4, 0, var1);
  136.          this.fContentModel = var4;
  137.          var3 = new int[var1 * 2][];
  138.          System.arraycopy(this.fAttlistHead, 0, var3, 0, var1);
  139.          this.fAttlistHead = var3;
  140.          var3 = new int[var1 * 2][];
  141.          System.arraycopy(this.fAttlistTail, 0, var3, 0, var1);
  142.          this.fAttlistTail = var3;
  143.       } catch (NullPointerException var6) {
  144.       }
  145.  
  146.       this.fElementName[var1] = new int[32];
  147.       this.fContentSpecType[var1] = new byte[32];
  148.       this.fContentSpec[var1] = new int[32];
  149.       this.fContentModel[var1] = new ContentModel[32];
  150.       this.fAttlistHead[var1] = new int[32];
  151.       this.fAttlistTail[var1] = new int[32];
  152.       return true;
  153.    }
  154.  
  155.    public int getElement(int var1) {
  156.       int var2 = var1 % 128;
  157.       int[] var3 = this.fElementNameHashtable[var2];
  158.       if (var3 != null) {
  159.          int var4 = 1;
  160.  
  161.          for(int var5 = 0; var5 < var3[0]; ++var5) {
  162.             if (var3[var4] == var1) {
  163.                return var3[var4 + 1];
  164.             }
  165.  
  166.             var4 += 2;
  167.          }
  168.       }
  169.  
  170.       return -1;
  171.    }
  172.  
  173.    public int addElement(int var1) {
  174.       int var2 = var1 % 128;
  175.       int[] var3 = this.fElementNameHashtable[var2];
  176.       if (var3 != null) {
  177.          int var4 = 1;
  178.  
  179.          for(int var5 = 0; var5 < var3[0]; ++var5) {
  180.             if (var3[var4] == var1) {
  181.                return var3[var4 + 1];
  182.             }
  183.  
  184.             var4 += 2;
  185.          }
  186.       }
  187.  
  188.       int var11 = this.fElementCount >> 5;
  189.       int var12 = this.fElementCount & 31;
  190.       this.ensureElementCapacity(var11);
  191.       this.fElementName[var11][var12] = var1;
  192.       this.fContentSpecType[var11][var12] = 0;
  193.       this.fContentSpec[var11][var12] = -1;
  194.       this.fContentModel[var11][var12] = null;
  195.       this.fAttlistHead[var11][var12] = -1;
  196.       this.fAttlistTail[var11][var12] = -1;
  197.       if (var3 == null) {
  198.          var3 = new int[9];
  199.          var3[0] = 1;
  200.          var3[1] = var1;
  201.          var3[2] = this.fElementCount;
  202.          this.fElementNameHashtable[var2] = var3;
  203.       } else {
  204.          int var6 = var3[0];
  205.          int var7 = 1 + var6 * 2;
  206.          if (var7 == var3.length) {
  207.             int var8 = var6 + 4;
  208.             int[] var9 = new int[1 + var8 * 2];
  209.             System.arraycopy(var3, 0, var9, 0, var7);
  210.             var3 = var9;
  211.             this.fElementNameHashtable[var2] = var9;
  212.          }
  213.  
  214.          var3[var7++] = var1;
  215.          var3[var7++] = this.fElementCount;
  216.          ++var6;
  217.          var3[0] = var6;
  218.       }
  219.  
  220.       return this.fElementCount++;
  221.    }
  222.  
  223.    public int addElementDecl(ElementDecl var1) {
  224.       int var2 = var1.elementName;
  225.       int var3 = var2 % 128;
  226.       int[] var4 = this.fElementNameHashtable[var3];
  227.       if (var4 != null) {
  228.          int var5 = 1;
  229.  
  230.          for(int var6 = 0; var6 < var4[0]; ++var6) {
  231.             if (var4[var5] == var2) {
  232.                int var7 = var4[var5 + 1];
  233.                int var8 = var7 >> 5;
  234.                int var9 = var7 & 31;
  235.                if (this.fContentSpecType[var8][var9] != 0) {
  236.                   return -1;
  237.                }
  238.  
  239.                this.fContentSpecType[var8][var9] = (byte)var1.contentSpecType;
  240.                this.fContentSpec[var8][var9] = var1.contentSpec;
  241.                this.fContentModel[var8][var9] = null;
  242.                return var7;
  243.             }
  244.  
  245.             var5 += 2;
  246.          }
  247.       }
  248.  
  249.       int var12 = this.fElementCount >> 5;
  250.       int var13 = this.fElementCount & 31;
  251.       this.ensureElementCapacity(var12);
  252.       this.fElementName[var12][var13] = var1.elementName;
  253.       this.fContentSpecType[var12][var13] = (byte)var1.contentSpecType;
  254.       this.fContentSpec[var12][var13] = var1.contentSpec;
  255.       this.fContentModel[var12][var13] = null;
  256.       this.fAttlistHead[var12][var13] = -1;
  257.       this.fAttlistTail[var12][var13] = -1;
  258.       if (var4 == null) {
  259.          var4 = new int[9];
  260.          var4[0] = 1;
  261.          var4[1] = var2;
  262.          var4[2] = this.fElementCount;
  263.          this.fElementNameHashtable[var3] = var4;
  264.       } else {
  265.          int var14 = var4[0];
  266.          int var16 = 1 + var14 * 2;
  267.          if (var16 == var4.length) {
  268.             int var19 = var14 + 4;
  269.             int[] var10 = new int[1 + var19 * 2];
  270.             System.arraycopy(var4, 0, var10, 0, var16);
  271.             var4 = var10;
  272.             this.fElementNameHashtable[var3] = var10;
  273.          }
  274.  
  275.          var4[var16++] = var2;
  276.          var4[var16++] = this.fElementCount;
  277.          ++var14;
  278.          var4[0] = var14;
  279.       }
  280.  
  281.       return this.fElementCount++;
  282.    }
  283.  
  284.    public int getElementName(int var1) {
  285.       if (var1 >= 0 && var1 < this.fElementCount) {
  286.          int var2 = var1 >> 5;
  287.          int var3 = var1 & 31;
  288.          return this.fElementName[var2][var3];
  289.       } else {
  290.          return -1;
  291.       }
  292.    }
  293.  
  294.    public int getContentSpecType(int var1) {
  295.       if (var1 >= 0 && var1 < this.fElementCount) {
  296.          int var2 = var1 >> 5;
  297.          int var3 = var1 & 31;
  298.          return this.fContentSpecType[var2][var3];
  299.       } else {
  300.          return -1;
  301.       }
  302.    }
  303.  
  304.    public int getContentSpec(int var1) {
  305.       if (var1 >= 0 && var1 < this.fElementCount) {
  306.          int var2 = var1 >> 5;
  307.          int var3 = var1 & 31;
  308.          return this.fContentSpec[var2][var3];
  309.       } else {
  310.          return -1;
  311.       }
  312.    }
  313.  
  314.    public String getContentSpecAsString(int var1) {
  315.       if (var1 >= 0 && var1 < this.fElementCount) {
  316.          int var2 = var1 >> 5;
  317.          int var3 = var1 & 31;
  318.          switch (this.fContentSpecType[var2][var3]) {
  319.             case 1:
  320.                return "EMPTY";
  321.             case 2:
  322.                return "ANY";
  323.             case 3:
  324.             case 4:
  325.                return this.getContentSpecNodeAsString(this.fContentSpec[var2][var3]);
  326.             default:
  327.                return null;
  328.          }
  329.       } else {
  330.          return null;
  331.       }
  332.    }
  333.  
  334.    public ContentModel getContentModel(int var1) {
  335.       if (var1 >= 0 && var1 < this.fElementCount) {
  336.          int var2 = var1 >> 5;
  337.          int var3 = var1 & 31;
  338.          return this.fContentModel[var2][var3];
  339.       } else {
  340.          return null;
  341.       }
  342.    }
  343.  
  344.    public void setContentModel(int var1, ContentModel var2) {
  345.       if (var1 >= 0 && var1 < this.fElementCount) {
  346.          int var3 = var1 >> 5;
  347.          int var4 = var1 & 31;
  348.          this.fContentModel[var3][var4] = var2;
  349.       }
  350.    }
  351.  
  352.    private boolean ensureNodeCapacity(int var1) {
  353.       try {
  354.          if (this.fNodeType[var1][0] != 0) {
  355.             return false;
  356.          }
  357.  
  358.          return true;
  359.       } catch (ArrayIndexOutOfBoundsException var4) {
  360.          byte[][] var2 = new byte[var1 * 2][];
  361.          System.arraycopy(this.fNodeType, 0, var2, 0, var1);
  362.          this.fNodeType = var2;
  363.          int[][] var3 = new int[var1 * 2][];
  364.          System.arraycopy(this.fNodeValue, 0, var3, 0, var1);
  365.          this.fNodeValue = var3;
  366.       } catch (NullPointerException var5) {
  367.       }
  368.  
  369.       this.fNodeType[var1] = new byte[32];
  370.       this.fNodeValue[var1] = new int[32];
  371.       return true;
  372.    }
  373.  
  374.    public int addContentSpecNode(ContentSpecNode var1) {
  375.       int var2 = this.fNodeCount >> 5;
  376.       int var3 = this.fNodeCount & 31;
  377.       this.ensureNodeCapacity(var2);
  378.       switch (var1.type) {
  379.          case 0:
  380.          case 1:
  381.          case 2:
  382.          case 3:
  383.             this.fNodeType[var2][var3] = (byte)var1.type;
  384.             this.fNodeValue[var2][var3] = var1.value;
  385.             return this.fNodeCount++;
  386.          case 4:
  387.          case 5:
  388.             this.fNodeType[var2][var3] = (byte)var1.type;
  389.             this.fNodeValue[var2][var3] = var1.value;
  390.             int var4 = this.fNodeCount++;
  391.             ++var3;
  392.             if (var3 == 32) {
  393.                ++var2;
  394.                this.ensureNodeCapacity(var2);
  395.                var3 = 0;
  396.             }
  397.  
  398.             this.fNodeType[var2][var3] = (byte)(var1.type | 64);
  399.             this.fNodeValue[var2][var3] = var1.otherValue;
  400.             ++this.fNodeCount;
  401.             return var4;
  402.          default:
  403.             return -1;
  404.       }
  405.    }
  406.  
  407.    public void getContentSpecNode(int var1, ContentSpecNode var2) {
  408.       int var3 = var1 >> 5;
  409.       int var4 = var1 & 31;
  410.       var2.type = this.fNodeType[var3][var4];
  411.       var2.value = this.fNodeValue[var3][var4];
  412.       if (var2.type != 4 && var2.type != 5) {
  413.          var2.otherValue = -1;
  414.       } else {
  415.          ++var4;
  416.          if (var4 == 32) {
  417.             ++var3;
  418.             var4 = 0;
  419.          }
  420.  
  421.          var2.otherValue = this.fNodeValue[var3][var4];
  422.       }
  423.    }
  424.  
  425.    private void appendContentSpecNode(int var1, StringBuffer var2, boolean var3) {
  426.       int var4 = var1 >> 5;
  427.       int var5 = var1 & 31;
  428.       byte var6 = this.fNodeType[var4][var5];
  429.       int var7 = this.fNodeValue[var4][var5];
  430.       switch (var6) {
  431.          case 0:
  432.             var2.append(var7 == -1 ? "#PCDATA" : this.fStringPool.toString(var7));
  433.             return;
  434.          case 1:
  435.             this.appendContentSpecNode(var7, var2, false);
  436.             var2.append('?');
  437.             return;
  438.          case 2:
  439.             this.appendContentSpecNode(var7, var2, false);
  440.             var2.append('*');
  441.             return;
  442.          case 3:
  443.             this.appendContentSpecNode(var7, var2, false);
  444.             var2.append('+');
  445.             return;
  446.          case 4:
  447.          case 5:
  448.             if (!var3) {
  449.                var2.append('(');
  450.             }
  451.  
  452.             int var8 = var7 >> 5;
  453.             int var9 = var7 & 31;
  454.             byte var10 = this.fNodeType[var8][var9];
  455.             this.appendContentSpecNode(var7, var2, var10 == var6);
  456.             var2.append((char)(var6 == 4 ? '|' : ','));
  457.             ++var5;
  458.             if (var5 == 32) {
  459.                ++var4;
  460.                var5 = 0;
  461.             }
  462.  
  463.             this.appendContentSpecNode(this.fNodeValue[var4][var5], var2, false);
  464.             if (!var3) {
  465.                var2.append(')');
  466.             }
  467.  
  468.             return;
  469.          default:
  470.       }
  471.    }
  472.  
  473.    public String getContentSpecNodeAsString(int var1) {
  474.       int var2 = var1 >> 5;
  475.       int var3 = var1 & 31;
  476.       byte var4 = this.fNodeType[var2][var3];
  477.       int var5 = this.fNodeValue[var2][var3];
  478.       StringBuffer var6 = new StringBuffer();
  479.       switch (var4) {
  480.          case 0:
  481.             var6.append("(" + (var5 == -1 ? "#PCDATA" : this.fStringPool.toString(var5)) + ")");
  482.             break;
  483.          case 1:
  484.             var2 = var5 >> 5;
  485.             var3 = var5 & 31;
  486.             if (this.fNodeType[var2][var3] == 0) {
  487.                var5 = this.fNodeValue[var2][var3];
  488.                var6.append("(" + (var5 == -1 ? "#PCDATA" : this.fStringPool.toString(var5)) + ")?");
  489.             } else {
  490.                this.appendContentSpecNode(var1, var6, false);
  491.             }
  492.             break;
  493.          case 2:
  494.             var2 = var5 >> 5;
  495.             var3 = var5 & 31;
  496.             if (this.fNodeType[var2][var3] == 0) {
  497.                var5 = this.fNodeValue[var2][var3];
  498.                var6.append("(" + (var5 == -1 ? "#PCDATA" : this.fStringPool.toString(var5)) + ")*");
  499.             } else {
  500.                this.appendContentSpecNode(var1, var6, false);
  501.             }
  502.             break;
  503.          case 3:
  504.             var2 = var5 >> 5;
  505.             var3 = var5 & 31;
  506.             if (this.fNodeType[var2][var3] == 0) {
  507.                var5 = this.fNodeValue[var2][var3];
  508.                var6.append("(" + (var5 == -1 ? "#PCDATA" : this.fStringPool.toString(var5)) + ")+");
  509.             } else {
  510.                this.appendContentSpecNode(var1, var6, false);
  511.             }
  512.             break;
  513.          case 4:
  514.          case 5:
  515.             this.appendContentSpecNode(var1, var6, false);
  516.             break;
  517.          default:
  518.             return null;
  519.       }
  520.  
  521.       return var6.toString();
  522.    }
  523.  
  524.    private boolean ensureAttrCapacity(int var1) {
  525.       try {
  526.          if (this.fAttName[var1][0] != 0) {
  527.             return false;
  528.          }
  529.  
  530.          return true;
  531.       } catch (ArrayIndexOutOfBoundsException var4) {
  532.          byte[][] var2 = new byte[var1 * 2][];
  533.          System.arraycopy(this.fAttType, 0, var2, 0, var1);
  534.          this.fAttType = var2;
  535.          var2 = new byte[var1 * 2][];
  536.          System.arraycopy(this.fAttDefaultType, 0, var2, 0, var1);
  537.          this.fAttDefaultType = var2;
  538.          int[][] var3 = new int[var1 * 2][];
  539.          System.arraycopy(this.fAttName, 0, var3, 0, var1);
  540.          this.fAttName = var3;
  541.          var3 = new int[var1 * 2][];
  542.          System.arraycopy(this.fEnumeration, 0, var3, 0, var1);
  543.          this.fEnumeration = var3;
  544.          var3 = new int[var1 * 2][];
  545.          System.arraycopy(this.fAttValue, 0, var3, 0, var1);
  546.          this.fAttValue = var3;
  547.          var3 = new int[var1 * 2][];
  548.          System.arraycopy(this.fNextAttDef, 0, var3, 0, var1);
  549.          this.fNextAttDef = var3;
  550.       } catch (NullPointerException var5) {
  551.       }
  552.  
  553.       this.fAttType[var1] = new byte[32];
  554.       this.fAttDefaultType[var1] = new byte[32];
  555.       this.fAttName[var1] = new int[32];
  556.       this.fEnumeration[var1] = new int[32];
  557.       this.fAttValue[var1] = new int[32];
  558.       this.fNextAttDef[var1] = new int[32];
  559.       return true;
  560.    }
  561.  
  562.    public int addAttDef(int var1, AttDef var2) throws Exception {
  563.       int var3 = var1 >> 5;
  564.       int var4 = var1 & 31;
  565.  
  566.       int var6;
  567.       int var7;
  568.       for(int var5 = this.fAttlistHead[var3][var4]; var5 != -1; var5 = this.fNextAttDef[var6][var7]) {
  569.          var6 = var5 >> 5;
  570.          var7 = var5 & 31;
  571.          if (this.fAttName[var6][var7] == var2.attName) {
  572.             if (this.fParserState.getWarningOnDuplicateAttDef()) {
  573.                this.fErrorHandler.error1(15, var2.attName);
  574.             }
  575.  
  576.             return -1;
  577.          }
  578.  
  579.          if (var2.attType == 1 && this.fAttType[var6][var7] == 1) {
  580.             this.fErrorHandler.error1(13, var2.attName);
  581.             return -1;
  582.          }
  583.       }
  584.  
  585.       if (this.fXMLSpace == -1) {
  586.          this.fXMLSpace = this.fStringPool.addSymbol("xml:space".intern());
  587.          this.fDefault = this.fStringPool.addSymbol("default".intern());
  588.          this.fPreserve = this.fStringPool.addSymbol("preserve".intern());
  589.       }
  590.  
  591.       if (var2.attName == this.fXMLSpace) {
  592.          var6 = 0;
  593.          if (var2.attType == 9) {
  594.             var7 = var2.enumeration;
  595.             if (var7 != -1) {
  596.                var6 = this.fStringPool.stringListLength(var7) == 2 && this.fStringPool.stringInList(var7, this.fDefault) && this.fStringPool.stringInList(var7, this.fPreserve);
  597.             }
  598.          }
  599.  
  600.          if (!var6) {
  601.             this.fErrorHandler.error(14);
  602.          }
  603.       }
  604.  
  605.       var6 = this.fAttDefCount >> 5;
  606.       var7 = this.fAttDefCount & 31;
  607.       this.ensureAttrCapacity(var6);
  608.       this.fAttName[var6][var7] = var2.attName;
  609.       this.fAttType[var6][var7] = (byte)var2.attType;
  610.       this.fEnumeration[var6][var7] = var2.enumeration;
  611.       this.fAttDefaultType[var6][var7] = (byte)var2.attDefaultType;
  612.       this.fAttValue[var6][var7] = var2.attValue;
  613.       int var8 = -1;
  614.       if (var2.attValue != -1) {
  615.          var8 = this.fAttlistHead[var3][var4];
  616.          this.fAttlistHead[var3][var4] = this.fAttDefCount;
  617.          if (var8 == -1) {
  618.             this.fAttlistTail[var3][var4] = this.fAttDefCount;
  619.          }
  620.       } else {
  621.          var8 = this.fAttlistTail[var3][var4];
  622.          this.fAttlistTail[var3][var4] = this.fAttDefCount;
  623.          if (var8 == -1) {
  624.             this.fAttlistHead[var3][var4] = this.fAttDefCount;
  625.          } else {
  626.             this.fNextAttDef[var8 >> 5][var8 & 31] = this.fAttDefCount;
  627.             var8 = -1;
  628.          }
  629.       }
  630.  
  631.       this.fNextAttDef[var6][var7] = var8;
  632.       return this.fAttDefCount++;
  633.    }
  634.  
  635.    public int getAttDef(int var1, int var2) {
  636.       int var3 = 0;
  637.       int var4 = 0;
  638.  
  639.       for(int var5 = 0; var5 < this.fElementCount; ++var5) {
  640.          if (this.fElementName[var3][var4] == var1) {
  641.             for(int var6 = this.fAttlistHead[var3][var4]; var6 != -1; var6 = this.fNextAttDef[var3][var4]) {
  642.                var3 = var6 >> 5;
  643.                var4 = var6 & 31;
  644.                if (this.fAttName[var3][var4] == var2) {
  645.                   return var6;
  646.                }
  647.             }
  648.  
  649.             return -1;
  650.          }
  651.  
  652.          ++var4;
  653.          if (var4 == 32) {
  654.             ++var3;
  655.             var4 = 0;
  656.          }
  657.       }
  658.  
  659.       return -1;
  660.    }
  661.  
  662.    public int getAttName(int var1) {
  663.       int var2 = var1 >> 5;
  664.       int var3 = var1 & 31;
  665.       return this.fAttName[var2][var3];
  666.    }
  667.  
  668.    public int getAttValue(int var1) {
  669.       int var2 = var1 >> 5;
  670.       int var3 = var1 & 31;
  671.       return this.fAttValue[var2][var3];
  672.    }
  673.  
  674.    public int getAttType(int var1) {
  675.       int var2 = var1 >> 5;
  676.       int var3 = var1 & 31;
  677.       return this.fAttType[var2][var3];
  678.    }
  679.  
  680.    public int getAttDefaultType(int var1) {
  681.       int var2 = var1 >> 5;
  682.       int var3 = var1 & 31;
  683.       return this.fAttDefaultType[var2][var3];
  684.    }
  685.  
  686.    public int getEnumeration(int var1) {
  687.       int var2 = var1 >> 5;
  688.       int var3 = var1 & 31;
  689.       return this.fEnumeration[var2][var3];
  690.    }
  691.  
  692.    public int addDefaultAttributes(int var1, AttrPool var2, int var3, int var4) throws Exception {
  693.       int var5 = var1 >> 5;
  694.       int var6 = var1 & 31;
  695.       int var7 = this.fAttlistHead[var5][var6];
  696.       int var8 = var3;
  697.  
  698.       int var10;
  699.       int var11;
  700.       for(int var9 = var4; var7 != -1; var7 = this.fNextAttDef[var10][var11]) {
  701.          var10 = var7 >> 5;
  702.          var11 = var7 & 31;
  703.          byte var12 = this.fAttDefaultType[var10][var11];
  704.          if (var12 != 3) {
  705.             int var13 = this.fAttName[var10][var11];
  706.             boolean var14 = false;
  707.             if (var8 != -1) {
  708.                for(int var15 = var8; var15 <= var9; ++var15) {
  709.                   var2.getAttrName(var15);
  710.                   if (var2.getAttrName(var15) == var13) {
  711.                      if (var12 == 4 && var2.getAttValue(var15) != this.fAttValue[var10][var11]) {
  712.                         this.fErrorHandler.error3(134, var13, this.fAttValue[var10][var11], var2.getAttValue(var15));
  713.                      }
  714.  
  715.                      var14 = true;
  716.                      break;
  717.                   }
  718.                }
  719.             }
  720.  
  721.             if (!var14) {
  722.                if (var12 == 2) {
  723.                   this.fErrorHandler.error1(133, var13);
  724.                } else {
  725.                   this.fAttr.attName = var13;
  726.                   this.fAttr.attType = this.fAttType[var10][var11];
  727.                   this.fAttr.attValue = this.fAttValue[var10][var11];
  728.                   this.fAttr.specified = false;
  729.                   var4 = var2.addAttr(this.fAttr, -1);
  730.                   if (var3 == -1) {
  731.                      var3 = var4;
  732.                   }
  733.                }
  734.             }
  735.          }
  736.       }
  737.  
  738.       if (var4 != -1) {
  739.          var2.setIsLastAttr(var4);
  740.       }
  741.  
  742.       return var3;
  743.    }
  744.  
  745.    public boolean addId(int var1, int var2) {
  746.       Integer var3 = new Integer(var1);
  747.       if (this.fIdDefs == null) {
  748.          this.fIdDefs = new Hashtable();
  749.       } else if (this.fIdDefs.containsKey(var3)) {
  750.          return false;
  751.       }
  752.  
  753.       if (this.fNullValue == null) {
  754.          this.fNullValue = new Object();
  755.       }
  756.  
  757.       this.fIdDefs.put(var3, this.fNullValue);
  758.       return true;
  759.    }
  760.  
  761.    public void addIdRef(int var1, int var2) {
  762.       Integer var3 = new Integer(var1);
  763.       if (this.fIdDefs == null || !this.fIdDefs.containsKey(var3)) {
  764.          if (this.fIdRefs == null) {
  765.             this.fIdRefs = new Hashtable();
  766.          } else if (this.fIdRefs.containsKey(var3)) {
  767.             return;
  768.          }
  769.  
  770.          if (this.fNullValue == null) {
  771.             this.fNullValue = new Object();
  772.          }
  773.  
  774.          this.fIdRefs.put(var3, this.fNullValue);
  775.       }
  776.    }
  777.  
  778.    public void checkIdRefs() throws Exception {
  779.       if (this.fIdRefs != null) {
  780.          Enumeration var1 = this.fIdRefs.keys();
  781.  
  782.          while(var1.hasMoreElements()) {
  783.             Integer var2 = (Integer)var1.nextElement();
  784.             if (this.fIdDefs == null || !this.fIdDefs.containsKey(var2)) {
  785.                this.fErrorHandler.error1(84, var2);
  786.             }
  787.          }
  788.  
  789.       }
  790.    }
  791.  
  792.    public void checkNamespace(int var1, int var2) throws Exception {
  793.       if (var2 != -1) {
  794.          int var4 = this.fAttrPool.getAttrName(var2);
  795.          String var5 = this.fStringPool.toString(var4);
  796.          int var6 = this.checkQName(var1, var5);
  797.          if (var6 != -1) {
  798.             this.fErrorHandler.error1(var6, var4);
  799.          }
  800.  
  801.          int var7 = this.fAttrPool.getAttValue(var2);
  802.          String var8 = this.fStringPool.toString(var7);
  803.          if (var8.length() == 0 && var5.startsWith("xmlns:")) {
  804.             this.fErrorHandler.error1(142, var4);
  805.          }
  806.  
  807.          if (this.localpartcache.length == 0) {
  808.             int[] var9 = new int[0];
  809.             System.arraycopy(this.localpartcache, 0, var9, 0, 0);
  810.             this.localpartcache = var9;
  811.             var9 = new int[0];
  812.             System.arraycopy(this.nsnamecache, 0, var9, 0, 0);
  813.             this.nsnamecache = var9;
  814.          }
  815.  
  816.          this.localpartcache[0] = this.getNSLocalName(var5, var4);
  817.          this.nsnamecache[0] = this.getNSName(var1, var5);
  818.          if (this.nsnamecache[0] != -1) {
  819.             for(int var14 = 0; var14 < 0; ++var14) {
  820.                if (this.localpartcache[var14] == this.localpartcache[0]) {
  821.                   int var10 = this.nsnamecache[var14];
  822.                   if (var10 != -1 && var10 == this.nsnamecache[0]) {
  823.                      this.fErrorHandler.error4(144, var4, this.nsnamecache[0], this.localpartcache[0], this.fAttrPool.getAttrName(var2 + var14));
  824.                   }
  825.                }
  826.             }
  827.          }
  828.       }
  829.  
  830.       int var3 = this.getElementName(var1);
  831.       String var11 = this.fStringPool.toString(var3);
  832.       int var12 = this.checkQName(var1, var11);
  833.       if (var12 != -1) {
  834.          this.fErrorHandler.error1(var12, var3);
  835.       }
  836.  
  837.    }
  838.  
  839.    public void checkDeclaredElements() throws Exception {
  840.       if (this.fParserState.getValidationHandler() != null) {
  841.          for(int var1 = 0; var1 < this.fElementCount; ++var1) {
  842.             int var2 = this.getContentSpecType(var1);
  843.             if (var2 == 3 || var2 == 4) {
  844.                int var3 = var1 >> 5;
  845.                int var4 = var1 & 31;
  846.                int var5 = this.fContentSpec[var3][var4];
  847.                this.checkDeclaredElements(var1, var5);
  848.             }
  849.          }
  850.       }
  851.  
  852.    }
  853.  
  854.    private void checkDeclaredElements(int var1, int var2) throws Exception {
  855.       int var3 = var2 >> 5;
  856.       int var4 = var2 & 31;
  857.       byte var5 = this.fNodeType[var3][var4];
  858.       int var6 = this.fNodeValue[var3][var4];
  859.       switch (var5) {
  860.          case 0:
  861.             if (var6 != -1 && this.getElement(var6) == -1) {
  862.                int var7 = var1 >> 5;
  863.                int var8 = var1 & 31;
  864.                int var9 = this.fElementName[var7][var8];
  865.                this.fErrorHandler.error2(165, var9, var6);
  866.                return;
  867.             }
  868.          default:
  869.             return;
  870.          case 1:
  871.          case 2:
  872.          case 3:
  873.             this.checkDeclaredElements(var1, var6);
  874.             return;
  875.          case 4:
  876.          case 5:
  877.             this.checkDeclaredElements(var1, var6);
  878.             ++var4;
  879.             if (var4 == 32) {
  880.                ++var3;
  881.                var4 = 0;
  882.             }
  883.  
  884.             this.checkDeclaredElements(var1, this.fNodeValue[var3][var4]);
  885.       }
  886.    }
  887.  
  888.    private int checkQName(int var1, String var2) {
  889.       int var3 = var2.indexOf(58);
  890.       if (var3 < 0) {
  891.          return -1;
  892.       } else {
  893.          var2.substring(0, var3);
  894.          if (-1 == -1) {
  895.             return 136;
  896.          } else {
  897.             return var2.indexOf(58, var3 + 1) >= 0 ? 135 : -1;
  898.          }
  899.       }
  900.    }
  901.  
  902.    private int getNSLocalName(String var1, int var2) {
  903.       int var3 = var1.indexOf(58);
  904.       return var3 < 0 ? var2 : this.fStringPool.addSymbol(var1.substring(var3 + 1));
  905.    }
  906.  
  907.    private int getNSName(int var1, String var2) {
  908.       int var3 = var2.indexOf(58);
  909.       if (var3 < 0) {
  910.          String var10000 = "";
  911.       } else {
  912.          var2.substring(0, var3);
  913.       }
  914.  
  915.       return -1;
  916.    }
  917.  
  918.    private int getNamespaceForPrefix(int var1, String var2) {
  919.       return -1;
  920.    }
  921. }
  922.