public TextCatalogReader() 
{

}

Construct a CatalogReader object.

 protected  void finalize() 
{
    if (catfile != null) {
      try {
        catfile.close();
      } catch (IOException e) {
        // whatever...
      }
    }
    catfile = null;
}

The destructor.

Makes sure the catalog file is closed.

 public boolean getCaseSensitive() 
{
    return caseSensitive;
}

 protected int nextChar() throws IOException 
{
    if (top <  0) {
      return catfile.read();
    } else {
      return stack[top--];
    }
}

Return the next logical character from the input stream.

 protected String nextToken() throws IOException, CatalogException 
{
    String token = "";
    int ch, nextch;
    if (!tokenStack.empty()) {
      return (String) tokenStack.pop();
    }
    // Skip over leading whitespace and comments
    while (true) {
      // skip leading whitespace
      ch = catfile.read();
      while (ch < = ' ") {      // all ctrls are whitespace
        ch = catfile.read();
        if (ch <  0) {
          return null;
        }
      }
      // now 'ch' is the current char from the file
      nextch = catfile.read();
      if (nextch <  0) {
        return null;
      }
      if (ch == '-" && nextch == '-") {
        // we've found a comment, skip it...
        ch = ' ";
        nextch = nextChar();
        while ((ch != '-" || nextch != '-") && nextch  > 0) {
          ch = nextch;
          nextch = nextChar();
        }
        if (nextch <  0) {
          throw new CatalogException(CatalogException.UNENDED_COMMENT,
                                     "Unterminated comment in catalog file; EOF treated as end-of-comment.");
        }
        // Ok, we've found the end of the comment,
        // loop back to the top and start again...
      } else {
        stack[++top] = nextch;
        stack[++top] = ch;
        break;
      }
    }
    ch = nextChar();
    if (ch == '"" || ch == '\'") {
      int quote = ch;
      while ((ch = nextChar()) != quote) {
        char[] chararr = new char[1];
        chararr[0] = (char) ch;
        String s = new String(chararr);
        token = token.concat(s);
      }
      return token;
    } else {
      // return the next whitespace or comment delimited
      // string
      while (ch  > ' ") {
        nextch = nextChar();
        if (ch == '-" && nextch == '-") {
          stack[++top] = ch;
          stack[++top] = nextch;
          return token;
        } else {
          char[] chararr = new char[1];
          chararr[0] = (char) ch;
          String s = new String(chararr);
          token = token.concat(s);
          ch = nextch;
        }
      }
      return token;
    }
}

Return the next token in the catalog file.

FYI: This code does not throw any sort of exception for a file that contains an n

 public  void readCatalog(Catalog catalog,
    String fileUrl) throws MalformedURLException, IOException 
{
    URL catURL = null;
    try {
      catURL = new URL(fileUrl);
    } catch (MalformedURLException e) {
      catURL = new URL("file:///" + fileUrl);
    }
    URLConnection urlCon = catURL.openConnection();
    try {
      readCatalog(catalog, urlCon.getInputStream());
    } catch (FileNotFoundException e) {
      catalog.getCatalogManager().debug.message(1, "Failed to load catalog, file not found",
                                                catURL.toString());
    }
}

Start parsing a text catalog file. The file is actually read and parsed as needed by nextEntry.

 public  void readCatalog(Catalog catalog,
    InputStream is) throws MalformedURLException, 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();
        }
        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());
      }
    }
}

 public  void setCaseSensitive(boolean isCaseSensitive) 
{
    caseSensitive = isCaseSensitive;
}