content: // TR9401CatalogReader.java - Read OASIS Catalog files
  
  /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   * 
   *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package mf.org.apache.xml.resolver.readers;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.util.Vector;
  
  import mf.org.apache.xml.resolver.Catalog;
  import mf.org.apache.xml.resolver.CatalogEntry;
  import mf.org.apache.xml.resolver.CatalogException;
  
  /**
   * Parses OASIS Open Catalog files.
   * <p/>
   * <p>This class reads OASIS Open Catalog files, returning a stream
   * of tokens.</p>
   * <p/>
   * <p>This code interrogates the following non-standard system properties:</p>
   * <p/>
   * <dl>
   * <dt><b>xml.catalog.debug</b></dt>
   * <dd><p>Sets the debug level. A value of 0 is assumed if the
   * property is not set or is not a number.</p></dd>
   * </dl>
   *
   * @author Norman Walsh
   *         <a href="mailto:Norman.Walsh@Sun.COM">Norman.Walsh@Sun.COM</a>
   * @version 1.0
   * @see Catalog
   */
  public class TR9401CatalogReader extends TextCatalogReader {
  
      /**
       * Start parsing an OASIS TR9401 Open Catalog file. The file is
       * actually read and parsed
       * as needed by <code>nextEntry</code>.
       * <p/>
       * <p>In a TR9401 Catalog the 'DELEGATE' entry delegates public
       * identifiers. There is no delegate entry for system identifiers
       * or URIs.</p>
       *
       * @param catalog The Catalog to populate
       * @param is      The input stream from which to read the TR9401 Catalog
       * @throws MalformedURLException Improper fileUrl
       * @throws IOException           Error reading catalog file
       */
      @Override
      public void readCatalog(Catalog catalog, InputStream is)
              throws IOException {
  
          catfile = is;
  
          if (catfile == null) {
              return;
          }
  
          Vector unknownEntry = null;
  
          try {
              while (true) {
                  String token = nextToken();
  
                  if (token == null) {
                      if (unknownEntry != null) {
                          catalog.unknownEntry(unknownEntry);
                          unknownEntry = null;
                      }
                      catfile.close();
                      catfile = null;
                      return;
                  }
  
                  String entryToken = null;
                  if (caseSensitive) {
                      entryToken = token;
                  } else {
                      entryToken = token.toUpperCase();
                  }
  
                  if (entryToken.equals("DELEGATE")) {
                      entryToken = "DELEGATE_PUBLIC";
                  }
  
                  try {
                      int type = CatalogEntry.getEntryType(entryToken);
                      int numArgs = CatalogEntry.getEntryArgCount(type);
                      Vector args = new Vector();
  
                      if (unknownEntry != null) {
                          catalog.unknownEntry(unknownEntry);
                          unknownEntry = null;
                      }
  
                      for (int count = 0; count < numArgs; count++) {
                          args.addElement(nextToken());
                      }
  
                      catalog.addEntry(new CatalogEntry(entryToken, args));
                  } catch (CatalogException cex) {
                      if (cex.getExceptionType() == CatalogException.INVALID_ENTRY_TYPE) {
                          if (unknownEntry == null) {
                              unknownEntry = new Vector();
                          }
                          unknownEntry.addElement(token);
                      } else if (cex.getExceptionType() == CatalogException.INVALID_ENTRY) {
                          catalog.getCatalogManager().debug.message(1, "Invalid catalog entry", token);
                          unknownEntry = null;
                      } else if (cex.getExceptionType() == CatalogException.UNENDED_COMMENT) {
                          catalog.getCatalogManager().debug.message(1, cex.getMessage());
                      }
                  }
              }
          } catch (CatalogException cex2) {
              if (cex2.getExceptionType() == CatalogException.UNENDED_COMMENT) {
                  catalog.getCatalogManager().debug.message(1, cex2.getMessage());
              }
          }
  
      }
  }
  