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 / parser / DTD.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-08-30  |  12.4 KB  |  716 lines
  1. package com.ibm.xml.parser;
  2.  
  3. import com.ibm.xml.framework.ParserState;
  4. import com.ibm.xml.framework.StringPool;
  5. import com.ibm.xml.framework.XMLErrorHandler;
  6. import java.io.IOException;
  7. import java.io.Writer;
  8. import java.util.Enumeration;
  9. import java.util.Hashtable;
  10. import java.util.StringTokenizer;
  11. import java.util.Vector;
  12. import org.w3c.dom.DOMException;
  13. import org.w3c.dom.DocumentType;
  14. import org.w3c.dom.Element;
  15. import org.w3c.dom.NamedNodeMap;
  16. import org.w3c.dom.Node;
  17. import org.w3c.dom.Notation;
  18.  
  19. public class DTD extends Parent implements DocumentType {
  20.    static final long serialVersionUID = 8746509003209143695L;
  21.    private static final boolean DEBUG_VALIDATION = false;
  22.    public static final String CM_EOC = " *EOC* ";
  23.    public static final String CM_ERROR = " *ERROR* ";
  24.    public static final String CM_PCDATA = "#PCDATA";
  25.    private String name;
  26.    private String xmlEncoding;
  27.    private TXNodeList internalChildren;
  28.    private TXNodeList externalChildren = new TXNodeList();
  29.    private ExternalID externalID;
  30.    private Hashtable elementDecls = new Hashtable();
  31.    private Hashtable attListDecls = new Hashtable();
  32.    private Hashtable notationDecls = new Hashtable();
  33.    private boolean parsingExternal = false;
  34.    boolean isPrintInternalDTD = true;
  35.    private Hashtable idHash;
  36.    EntityPool entityPool;
  37.  
  38.    public DTD() {
  39.       this.internalChildren = super.children;
  40.    }
  41.  
  42.    public DTD(String var1, ExternalID var2) {
  43.       this.name = var1;
  44.       this.externalID = var2;
  45.       this.internalChildren = super.children;
  46.    }
  47.  
  48.    public Object clone() {
  49.       return this.cloneNode(true);
  50.    }
  51.  
  52.    public synchronized Node cloneNode(boolean var1) {
  53.       ((Child)this).checkFactory();
  54.       DTD var2 = super.factory.createDTD(this.name, this.externalID);
  55.       ((Child)var2).setFactory(((Child)this).getFactory());
  56.       var2.isPrintInternalDTD = this.isPrintInternalDTD;
  57.       var2.xmlEncoding = this.xmlEncoding;
  58.       EntityPool var3 = new EntityPool();
  59.       var3.add(super.factory.createEntityDecl("lt", "<", false));
  60.       var3.add(super.factory.createEntityDecl("gt", ">", false));
  61.       var3.add(super.factory.createEntityDecl("amp", "&", false));
  62.       var3.add(super.factory.createEntityDecl("apos", "'", false));
  63.       var3.add(super.factory.createEntityDecl("quot", """, false));
  64.       var2.setEntityPool(var3);
  65.       if (var1) {
  66.          var2.setParsingExternal(true);
  67.          var2.externalChildren.ensureCapacity(this.externalChildren.getLength());
  68.  
  69.          for(int var4 = 0; var4 < this.externalChildren.getLength(); ++var4) {
  70.             ((Parent)var2).appendChild((Child)((Child)this.externalChildren.item(var4)).clone());
  71.          }
  72.  
  73.          var2.setParsingExternal(false);
  74.          var2.internalChildren.ensureCapacity(this.internalChildren.getLength());
  75.  
  76.          for(int var5 = 0; var5 < this.internalChildren.getLength(); ++var5) {
  77.             ((Parent)var2).appendChild((Child)((Child)this.internalChildren.item(var5)).clone());
  78.          }
  79.       }
  80.  
  81.       var2.setParsingExternal(this.parsingExternal);
  82.       return var2;
  83.    }
  84.  
  85.    public short getNodeType() {
  86.       return 10;
  87.    }
  88.  
  89.    public String getNodeName() {
  90.       return this.name;
  91.    }
  92.  
  93.    public String getName() {
  94.       return this.name;
  95.    }
  96.  
  97.    public void setName(String var1) {
  98.       this.name = var1;
  99.    }
  100.  
  101.    public synchronized boolean equals(Node var1, boolean var2) {
  102.       if (var1 == null) {
  103.          return false;
  104.       } else if (!(var1 instanceof DTD)) {
  105.          return false;
  106.       } else {
  107.          DTD var3 = (DTD)var1;
  108.          if (var3.name == null && this.name == null || var3.name != null && var3.name.equals(this.name)) {
  109.             if (var3.externalID == null && this.externalID == null || var3.externalID != null && var3.externalID.equals(this.externalID)) {
  110.                if (var3.xmlEncoding == null && this.xmlEncoding == null || var3.xmlEncoding != null && var3.xmlEncoding.equalsIgnoreCase(this.xmlEncoding)) {
  111.                   if (var2) {
  112.                      if (!var3.internalChildren.equals(this.internalChildren, var2)) {
  113.                         return false;
  114.                      }
  115.  
  116.                      if (!var3.externalChildren.equals(this.externalChildren, var2)) {
  117.                         return false;
  118.                      }
  119.                   }
  120.  
  121.                   return true;
  122.                } else {
  123.                   return false;
  124.                }
  125.             } else {
  126.                return false;
  127.             }
  128.          } else {
  129.             return false;
  130.          }
  131.       }
  132.    }
  133.  
  134.    public void setParsingExternal(boolean var1) {
  135.       this.parsingExternal = var1;
  136.       super.children = var1 ? this.externalChildren : this.internalChildren;
  137.    }
  138.  
  139.    public boolean isParsingExternal() {
  140.       return this.parsingExternal;
  141.    }
  142.  
  143.    public Enumeration internalElements() {
  144.       return this.internalChildren.elements();
  145.    }
  146.  
  147.    public Enumeration externalElements() {
  148.       return this.externalChildren.elements();
  149.    }
  150.  
  151.    public ExternalID getExternalID() {
  152.       return this.externalID;
  153.    }
  154.  
  155.    public void setExternalID(ExternalID var1) {
  156.       this.externalID = var1;
  157.    }
  158.  
  159.    public Enumeration getAttributeDeclarations(String var1) {
  160.       Hashtable var2 = (Hashtable)this.attListDecls.get(var1);
  161.       if (var2 == null) {
  162.          var2 = new Hashtable();
  163.       }
  164.  
  165.       return var2.elements();
  166.    }
  167.  
  168.    public AttDef getAttributeDeclaration(String var1, String var2) {
  169.       Hashtable var3 = (Hashtable)this.attListDecls.get(var1);
  170.       return var3 == null ? null : (AttDef)var3.get(var2);
  171.    }
  172.  
  173.    public boolean isAttributeDeclared(String var1, String var2) {
  174.       return this.getAttributeDeclaration(var1, var2) != null;
  175.    }
  176.  
  177.    public Enumeration getElementDeclarations() {
  178.       return this.elementDecls.elements();
  179.    }
  180.  
  181.    public ElementDecl getElementDeclaration(String var1) {
  182.       return (ElementDecl)this.elementDecls.get(var1);
  183.    }
  184.  
  185.    public boolean isElementDeclared(String var1) {
  186.       return this.elementDecls.containsKey(var1);
  187.    }
  188.  
  189.    public Vector makeContentElementList(String var1) {
  190.       ElementDecl var2 = (ElementDecl)this.elementDecls.get(var1);
  191.       return var2 == null ? null : var2.getXML4JContentModel().getChildrenOrder();
  192.    }
  193.  
  194.    public Enumeration getNotationEnumeration() {
  195.       return this.notationDecls.elements();
  196.    }
  197.  
  198.    public Notation getNotation(String var1) {
  199.       TXNotation var2 = (TXNotation)this.notationDecls.get(var1);
  200.       return var2 == null ? null : var2.getNotationImpl();
  201.    }
  202.  
  203.    public NamedNodeMap getNotations() {
  204.       return new HashNamedNodeMap(this.notationDecls);
  205.    }
  206.  
  207.    public void setEncoding(String var1) {
  208.       this.xmlEncoding = var1;
  209.    }
  210.  
  211.    public void printExternal(Writer var1, String var2) throws IOException {
  212.       if (this.xmlEncoding != null) {
  213.          var1.write("<?xml encoding=\"" + this.xmlEncoding + "\"?>");
  214.       }
  215.  
  216.       for(int var3 = 0; var3 < this.externalChildren.getLength(); ++var3) {
  217.          ((Child)this.externalChildren.item(var3)).print(var1, var2);
  218.       }
  219.  
  220.       var1.flush();
  221.    }
  222.  
  223.    public boolean checkContent(TXElement var1) {
  224.       ElementDecl var2 = (ElementDecl)this.elementDecls.get(var1.getNodeName());
  225.       return var2 == null ? false : var2.getXML4JContentModel().check(var1);
  226.    }
  227.  
  228.    public Node validate(TXElement var1) {
  229.       return this.validate(var1, (ParserState)null);
  230.    }
  231.  
  232.    public Node validate(TXElement var1, ParserState var2) {
  233.       String var3 = var1.getNodeName();
  234.       ElementDecl var4 = (ElementDecl)this.elementDecls.get(var3);
  235.       if (var4 == null) {
  236.          if (var2 != null) {
  237.             StringPool var14 = var2.getStringPool();
  238.             int var6 = var14.addString(var3);
  239.  
  240.             try {
  241.                XMLErrorHandler var9 = var2.getErrorHandler();
  242.                var9.error1(166, var6);
  243.             } catch (Exception var12) {
  244.             } finally {
  245.                var14.releaseString(var6);
  246.             }
  247.          }
  248.  
  249.          return var1;
  250.       } else {
  251.          Node var5 = this.validateAttributes(var1, var2);
  252.          if (var5 == null) {
  253.             var5 = var4.getXML4JContentModel().validate(var1, var2);
  254.          }
  255.  
  256.          return var5;
  257.       }
  258.    }
  259.  
  260.    public ContentModel getContentModel(String var1) {
  261.       ElementDecl var2 = (ElementDecl)this.elementDecls.get(var1);
  262.       return var2 == null ? null : var2.getXML4JContentModel();
  263.    }
  264.  
  265.    public int getContentType(String var1) {
  266.       ElementDecl var2 = (ElementDecl)this.elementDecls.get(var1);
  267.       return var2 == null ? -1 : var2.getXML4JContentModel().getType();
  268.    }
  269.  
  270.    public Hashtable prepareTable(String var1) {
  271.       ElementDecl var2 = (ElementDecl)this.elementDecls.get(var1);
  272.       return var2 == null ? null : var2.getXML4JContentModel().prepareTable();
  273.    }
  274.  
  275.    public Hashtable getInsertableElements(Element var1, int var2, Hashtable var3) {
  276.       ContentModel var4 = this.getContentModel(var1.getNodeName());
  277.       return var4 == null ? null : var4.getInsertableElements(var1, var2, var3, false);
  278.    }
  279.  
  280.    public Hashtable getAppendableElements(Element var1, Hashtable var2) {
  281.       return this.getInsertableElements(var1, var1.getChildNodes().getLength(), var2);
  282.    }
  283.  
  284.    public Hashtable getInsertableElementsForValidContent(Element var1, int var2, Hashtable var3) {
  285.       ContentModel var4 = this.getContentModel(var1.getNodeName());
  286.       return var4 == null ? null : var4.getInsertableElements(var1, var2, var3, true);
  287.    }
  288.  
  289.    public boolean registID(Element var1, String var2) {
  290.       if (this.idHash == null) {
  291.          this.idHash = new Hashtable();
  292.       }
  293.  
  294.       if (this.idHash.containsKey(var2)) {
  295.          return false;
  296.       } else {
  297.          this.idHash.put(var2, var1);
  298.          return true;
  299.       }
  300.    }
  301.  
  302.    public boolean unregistID(String var1) {
  303.       if (this.idHash == null) {
  304.          return false;
  305.       } else if (!this.idHash.containsKey(var1)) {
  306.          return false;
  307.       } else {
  308.          this.idHash.remove(var1);
  309.          return true;
  310.       }
  311.    }
  312.  
  313.    public Element checkID(String var1) {
  314.       return this.idHash == null ? null : (Element)this.idHash.get(var1);
  315.    }
  316.  
  317.    public Enumeration IDs() {
  318.       return this.idHash == null ? (new Hashtable()).keys() : this.idHash.keys();
  319.    }
  320.  
  321.    public Enumeration getEntityEnumeration() {
  322.       return this.entityPool.elements();
  323.    }
  324.  
  325.    public Enumeration getParameterEntityEnumeration() {
  326.       return this.entityPool.parameterEntityElements();
  327.    }
  328.  
  329.    public EntityDecl getEntityDecl(String var1, boolean var2) {
  330.       EntityDecl var3;
  331.       if (var2) {
  332.          var3 = this.entityPool.referPara(var1);
  333.       } else {
  334.          var3 = this.entityPool.refer(var1);
  335.       }
  336.  
  337.       return var3;
  338.    }
  339.  
  340.    public NamedNodeMap getEntities() {
  341.       return new HashNamedNodeMap(this.entityPool.getEntityHash());
  342.    }
  343.  
  344.    public int getInternalSize() {
  345.       return this.internalChildren.getLength();
  346.    }
  347.  
  348.    public int getExternalSize() {
  349.       return this.externalChildren.getLength();
  350.    }
  351.  
  352.    public void setPrintInternalDTD(boolean var1) {
  353.       this.isPrintInternalDTD = var1;
  354.    }
  355.  
  356.    public boolean isPrintInternalDTD() {
  357.       return this.isPrintInternalDTD;
  358.    }
  359.  
  360.    public void acceptPre(Visitor var1) throws Exception {
  361.       var1.visitDTDPre(this);
  362.    }
  363.  
  364.    public void acceptPost(Visitor var1) throws Exception {
  365.       var1.visitDTDPost(this);
  366.    }
  367.  
  368.    public void setEntityPool(EntityPool var1) {
  369.       this.entityPool = var1;
  370.    }
  371.  
  372.    protected void realInsert(Node var1, int var2) throws DOMException {
  373.       if (var1 != null) {
  374.          super.realInsert(var1, var2);
  375.          if (var1 instanceof ElementDecl) {
  376.             ElementDecl var10 = (ElementDecl)var1;
  377.             this.elementDecls.put(var10.getName(), var10);
  378.          } else if (var1 instanceof Attlist) {
  379.             Attlist var9 = (Attlist)var1;
  380.             String var4 = var9.getName();
  381.             Hashtable var5 = (Hashtable)this.attListDecls.get(var4);
  382.             if (var5 == null) {
  383.                var5 = new Hashtable();
  384.                this.attListDecls.put(var4, var5);
  385.             }
  386.  
  387.             for(int var6 = 0; var6 < var9.size(); ++var6) {
  388.                AttDef var7 = var9.elementAt(var6);
  389.                if (var5.get(var7.getName()) == null) {
  390.                   var5.put(var7.getName(), var7);
  391.                }
  392.             }
  393.  
  394.          } else if (var1 instanceof TXNotation) {
  395.             TXNotation var8 = (TXNotation)var1;
  396.             this.notationDecls.put(var8.getNodeName(), var8);
  397.          } else {
  398.             if (var1 instanceof EntityDecl) {
  399.                EntityDecl var3 = (EntityDecl)var1;
  400.                this.entityPool.add(var3);
  401.             }
  402.  
  403.          }
  404.       }
  405.    }
  406.  
  407.    protected void checkChildType(Node var1) throws DOMException {
  408.       switch (var1.getNodeType()) {
  409.          case 3:
  410.          case 6:
  411.          case 7:
  412.          case 8:
  413.          case 12:
  414.          case 20:
  415.          case 21:
  416.          case 23:
  417.             return;
  418.          default:
  419.             throw new TXDOMException((short)3, "Specified node type (" + var1.getNodeType() + ") can't be a child of DocumentType.");
  420.       }
  421.    }
  422.  
  423.    Node validateAttributes(TXElement var1) {
  424.       return this.validateAttributes(var1, (ParserState)null);
  425.    }
  426.  
  427.    Node validateAttributes(TXElement var1, ParserState var2) {
  428.       NamedNodeMap var3 = var1.getAttributes();
  429.       String var4 = var1.getNodeName();
  430.       Hashtable var5 = (Hashtable)this.attListDecls.get(var4);
  431.       if (var5 != null && var5.size() != 0) {
  432.          if (var3 == null) {
  433.             Enumeration var244 = var5.keys();
  434.  
  435.             while(var244.hasMoreElements()) {
  436.                String var245 = (String)var244.nextElement();
  437.                AttDef var247 = (AttDef)var5.get(var245);
  438.                if (var247.getDefaultType() == 2) {
  439.                   return var1;
  440.                }
  441.             }
  442.          } else {
  443.             Vector var6 = new Vector();
  444.             Enumeration var7 = var5.keys();
  445.  
  446.             while(var7.hasMoreElements()) {
  447.                String var8 = (String)var7.nextElement();
  448.                var6.addElement(var5.get(var8));
  449.             }
  450.  
  451.             int var246 = var6.size();
  452.  
  453.             for(AttDef var9 = (AttDef)var6.firstElement(); var9 != null; var9 = var6.size() > 0 ? (AttDef)var6.firstElement() : null) {
  454.                String var10 = var9.getName();
  455.                Node var11 = var3.getNamedItem(var10);
  456.                int var12 = var9.getDefaultType();
  457.                switch (var12) {
  458.                   case 1:
  459.                      if (var11 != null && !var11.getNodeValue().equals(var9.getDefaultStringValue())) {
  460.                         return var11;
  461.                      }
  462.                      break;
  463.                   case 2:
  464.                      if (var11 == null) {
  465.                         return var1;
  466.                      }
  467.                }
  468.  
  469.                if (var11 != null) {
  470.                   int var13 = var9.getDeclaredType();
  471.                   String var14 = var11.getNodeValue();
  472.                   switch (var13) {
  473.                      case 1:
  474.                         int var260 = var14.length();
  475.  
  476.                         for(int var269 = 0; var269 < var260; ++var269) {
  477.                            char var278 = var14.charAt(var269);
  478.                            if (!XMLChar.isChar(var278)) {
  479.                               if (var2 != null) {
  480.                                  StringPool var283 = var2.getStringPool();
  481.                                  int var284 = var283.addString(Integer.toHexString(var278));
  482.  
  483.                                  try {
  484.                                     XMLErrorHandler var22 = var2.getErrorHandler();
  485.                                     var22.error1(85, var284);
  486.                                  } catch (Exception var242) {
  487.                                  } finally {
  488.                                     var283.releaseString(var284);
  489.                                  }
  490.                               }
  491.  
  492.                               return var11;
  493.                            }
  494.                         }
  495.                         break;
  496.                      case 2:
  497.                         String var259 = var14.trim();
  498.                         if (!Util.checkName(var259)) {
  499.                            if (var2 != null) {
  500.                               StringPool var268 = var2.getStringPool();
  501.                               int var277 = var268.addString(var259);
  502.  
  503.                               try {
  504.                                  XMLErrorHandler var289 = var2.getErrorHandler();
  505.                                  var289.error1(89, var277);
  506.                               } catch (Exception var240) {
  507.                               } finally {
  508.                                  var268.releaseString(var277);
  509.                               }
  510.                            }
  511.  
  512.                            return var11;
  513.                         }
  514.                         break;
  515.                      case 3:
  516.                         String var258 = var14.trim();
  517.                         if (this.idHash == null || this.idHash.get(var258) == null) {
  518.                            if (var2 != null) {
  519.                               StringPool var267 = var2.getStringPool();
  520.                               int var276 = var267.addString(var258);
  521.  
  522.                               try {
  523.                                  XMLErrorHandler var288 = var2.getErrorHandler();
  524.                                  var288.error1(84, var276);
  525.                               } catch (Exception var238) {
  526.                               } finally {
  527.                                  var267.releaseString(var276);
  528.                               }
  529.                            }
  530.  
  531.                            return var11;
  532.                         }
  533.                         break;
  534.                      case 4:
  535.                         StringTokenizer var257 = new StringTokenizer(var14);
  536.  
  537.                         while(var257.hasMoreTokens()) {
  538.                            String var266 = var257.nextToken();
  539.                            if (this.idHash == null || this.idHash.get(var266) == null) {
  540.                               if (var2 != null) {
  541.                                  StringPool var275 = var2.getStringPool();
  542.                                  int var282 = var275.addString(var266);
  543.  
  544.                                  try {
  545.                                     XMLErrorHandler var291 = var2.getErrorHandler();
  546.                                     var291.error1(84, var282);
  547.                                  } catch (Exception var236) {
  548.                                  } finally {
  549.                                     var275.releaseString(var282);
  550.                                  }
  551.                               }
  552.  
  553.                               return var11;
  554.                            }
  555.                         }
  556.                         break;
  557.                      case 5:
  558.                         String var256 = var14.trim();
  559.                         if (this.entityPool == null || this.entityPool.refer(var256) == null) {
  560.                            if (var2 != null) {
  561.                               StringPool var265 = var2.getStringPool();
  562.                               int var274 = var265.addString(var256);
  563.  
  564.                               try {
  565.                                  XMLErrorHandler var287 = var2.getErrorHandler();
  566.                                  var287.error1(60, var274);
  567.                               } catch (Exception var234) {
  568.                               } finally {
  569.                                  var265.releaseString(var274);
  570.                               }
  571.                            }
  572.  
  573.                            return var11;
  574.                         }
  575.                         break;
  576.                      case 6:
  577.                         StringTokenizer var255 = new StringTokenizer(var14);
  578.  
  579.                         while(var255.hasMoreTokens()) {
  580.                            String var264 = var255.nextToken();
  581.                            if (this.entityPool == null || this.entityPool.refer(var264) == null) {
  582.                               if (var2 != null) {
  583.                                  StringPool var273 = var2.getStringPool();
  584.                                  int var281 = var273.addString(var264);
  585.  
  586.                                  try {
  587.                                     XMLErrorHandler var290 = var2.getErrorHandler();
  588.                                     var290.error1(60, var281);
  589.                                  } catch (Exception var232) {
  590.                                  } finally {
  591.                                     var273.releaseString(var281);
  592.                                  }
  593.                               }
  594.  
  595.                               return var11;
  596.                            }
  597.                         }
  598.                         break;
  599.                      case 7:
  600.                         String var254 = var14.trim();
  601.                         if (!Util.checkNmtoken(var254)) {
  602.                            if (var2 != null) {
  603.                               StringPool var263 = var2.getStringPool();
  604.                               int var272 = var263.addString(var254);
  605.  
  606.                               try {
  607.                                  XMLErrorHandler var286 = var2.getErrorHandler();
  608.                                  var286.error1(90, var272);
  609.                               } catch (Exception var230) {
  610.                               } finally {
  611.                                  var263.releaseString(var272);
  612.                               }
  613.                            }
  614.  
  615.                            return var11;
  616.                         }
  617.                         break;
  618.                      case 8:
  619.                         StringTokenizer var253 = new StringTokenizer(var14);
  620.  
  621.                         while(var253.hasMoreTokens()) {
  622.                            String var262 = var253.nextToken();
  623.                            if (!Util.checkNmtoken(var262)) {
  624.                               if (var2 != null) {
  625.                                  StringPool var271 = var2.getStringPool();
  626.                                  int var280 = var271.addString(var262);
  627.  
  628.                                  try {
  629.                                     XMLErrorHandler var21 = var2.getErrorHandler();
  630.                                     var21.error1(90, var280);
  631.                                  } catch (Exception var228) {
  632.                                  } finally {
  633.                                     var271.releaseString(var280);
  634.                                  }
  635.                               }
  636.  
  637.                               return var11;
  638.                            }
  639.                         }
  640.                         break;
  641.                      case 9:
  642.                         String var252 = var14.trim();
  643.                         if (this.getNotation(var252) == null) {
  644.                            if (var2 != null) {
  645.                               StringPool var261 = var2.getStringPool();
  646.                               int var270 = var261.addString(var252);
  647.  
  648.                               try {
  649.                                  XMLErrorHandler var285 = var2.getErrorHandler();
  650.                                  var285.error1(76, var270);
  651.                               } catch (Exception var226) {
  652.                               } finally {
  653.                                  var261.releaseString(var270);
  654.                               }
  655.                            }
  656.  
  657.                            return var11;
  658.                         }
  659.                         break;
  660.                      case 10:
  661.                         boolean var15 = false;
  662.                         String var16 = var14.trim();
  663.                         Enumeration var17 = var9.elements();
  664.                         if (var17 != null) {
  665.                            while(var17.hasMoreElements()) {
  666.                               String var18 = (String)var17.nextElement();
  667.                               if (var16.equals(var18)) {
  668.                                  var15 = true;
  669.                                  break;
  670.                               }
  671.                            }
  672.                         }
  673.  
  674.                         if (!var15) {
  675.                            if (var2 != null) {
  676.                               StringPool var279 = var2.getStringPool();
  677.                               int var19 = var279.addString(var16);
  678.                               int var20 = var279.addString(var9.toString());
  679.  
  680.                               try {
  681.                                  XMLErrorHandler var23 = var2.getErrorHandler();
  682.                                  var23.error2(161, var19, var20);
  683.                               } catch (Exception var224) {
  684.                               } finally {
  685.                                  var279.releaseString(var19);
  686.                                  var279.releaseString(var20);
  687.                               }
  688.                            }
  689.  
  690.                            return var11;
  691.                         }
  692.                   }
  693.                }
  694.  
  695.                var6.removeElementAt(0);
  696.             }
  697.  
  698.             int var248 = var3.getLength();
  699.             if (var248 > var246) {
  700.                for(int var249 = 0; var249 < var248; ++var249) {
  701.                   Node var250 = var3.item(var249);
  702.                   String var251 = var250.getNodeName();
  703.                   if (this.getAttributeDeclaration(var4, var251) == null) {
  704.                      return var250;
  705.                   }
  706.                }
  707.             }
  708.          }
  709.       } else if (var3 != null && var3.getLength() > 0) {
  710.          return var3.item(0);
  711.       }
  712.  
  713.       return null;
  714.    }
  715. }
  716.