URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [javax/] [activation/] [MailcapCommandMap.java] - Blame information for rev 772

Details | Compare with Previous | View Log


/* MailcapCommandMap.java -- Command map implementation using a mailcap file.
   Copyright (C) 2004 Free Software Foundation, Inc.
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */
 
package javax.activation;
 
import gnu.java.lang.CPStringBuilder;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
 
/**
 * Implementation of a command map using a <code>mailcap</code> file (RFC
 * 1524). Mailcap files are searched for in the following places:
 * <ol>
 * <li>Programmatically added entries to this interface</li>
 * <li>the file <tt>.mailcap</tt> in the user's home directory</li>
 * <li>the file <i>&lt;java.home&gt;</i><tt>/lib/mailcap</tt></li>
 * <li>the resource <tt>META-INF/mailcap</tt></li>
 * <li>the resource <tt>META-INF/mailcap.default</tt> in the JAF
 * distribution</li>
 * </ol>
 *
 * @author <a href='mailto:dog@gnu.org'>Chris Burdess</a>
 * @version 1.1
 */
public class MailcapCommandMap
    extends CommandMap
{
 
  private static final int PROG = 0;
  private static final int HOME = 1;
  private static final int SYS = 2;
  private static final int JAR = 3;
  private static final int DEF = 4;
  private static boolean debug = false;
  private static final int NORMAL = 0;
  private static final int FALLBACK = 1;
 
  static
  {
    try
      {
        String d = System.getProperty("javax.activation.debug");
        debug = Boolean.valueOf(d).booleanValue();
      }
    catch (SecurityException e)
      {
      }
  }
 
  private Map<String,Map<String,List<String>>>[][] mailcaps;
 
  /**
   * Default constructor.
   */
  public MailcapCommandMap()
  {
    init(null);
  }
 
  /**
   * Constructor specifying a filename.
   * @param fileName the name of the file to read mailcap entries from
   */
  public MailcapCommandMap(String fileName)
    throws IOException
  {
    Reader in = null;
    try
      {
        in = new FileReader(fileName);
      }
    catch (IOException e)
      {
      }
    init(in);
    if (in != null)
      {
        try
          {
            in.close();
          }
        catch (IOException e)
          {
          }
      }
  }
 
  /**
   * Constructor specifying an input stream.
   * @param is the input stream to read mailcap entries from
   */
  public MailcapCommandMap(InputStream is)
  {
    init(new InputStreamReader(is));
  }
 
  private void init(Reader in)
  {
    mailcaps = new Map[5][2];
    for (int i = 0; i < 5; i++)
      {
        for (int j = 0; j < 2; j++)
          {
            mailcaps[i][j] =
              new LinkedHashMap<String,Map<String,List<String>>>();
          }
      }
    if (in != null)
      {
        if (debug)
          {
            System.out.println("MailcapCommandMap: load PROG");
          }
        try
          {
            parse(PROG, in);
          }
        catch (IOException e)
          {
          }
      }
 
    if (debug)
      {
        System.out.println("MailcapCommandMap: load HOME");
      }
    try
      {
        String home = System.getProperty("user.home");
        if (home != null)
          {
            parseFile(HOME, new CPStringBuilder(home)
                      .append(File.separatorChar)
                      .append(".mailcap")
                      .toString());
          }
      }
    catch (SecurityException e)
      {
      }
 
    if (debug)
      {
        System.out.println("MailcapCommandMap: load SYS");
      }
    try
      {
        parseFile(SYS,
                  new CPStringBuilder(System.getProperty("java.home"))
                  .append(File.separatorChar)
                  .append("lib")
                  .append(File.separatorChar)
                  .append("mailcap")
                  .toString());
      }
    catch (SecurityException e)
      {
      }
 
    if (debug)
      {
        System.out.println("MailcapCommandMap: load JAR");
      }
    List<URL> systemResources = getSystemResources("META-INF/mailcap");
    int len = systemResources.size();
    if (len > 0)
      {
        for (int i = 0; i < len ; i++)
          {
            Reader urlIn = null;
            URL url = systemResources.get(i);
            try
              {
                if (debug)
                  {
                    System.out.println("\t" + url.toString());
                  }
                urlIn = new InputStreamReader(url.openStream());
                parse(JAR, urlIn);
              }
            catch (IOException e)
              {
                if (debug)
                  {
                    System.out.println(e.getClass().getName() + ": " +
                                       e.getMessage());
                  }
              }
            finally
              {
                if (urlIn != null)
                  {
                    try
                      {
                        urlIn.close();
                      }
                    catch (IOException e)
                      {
                      }
                  }
              }
          }
      }
    else
      {
        parseResource(JAR, "/META-INF/mailcap");
      }
 
    if (debug)
      {
        System.out.println("MailcapCommandMap: load DEF");
      }
    parseResource(DEF, "/META-INF/mailcap.default");
  }
 
  /**
   * Returns the list of preferred commands for a given MIME type.
   * @param mimeType the MIME type
   */
  public synchronized CommandInfo[] getPreferredCommands(String mimeType)
  {
    List<CommandInfo> cmdList = new ArrayList<CommandInfo>();
    List<String> verbList = new ArrayList<String>();
    for (int i = 0; i < 2; i++)
      {
        for (int j = 0; j < 5; j++)
          {
            Map<String,List<String>> map = getCommands(mailcaps[j][i], mimeType);
            if (map != null)
              {
                for (Map.Entry<String,List<String>> entry : map.entrySet())
                  {
                    String verb = entry.getKey();
                    if (!verbList.contains(verb))
                      {
                        List<String> classNames = entry.getValue();
                        String className = classNames.get(0);
                        CommandInfo cmd = new CommandInfo(verb, className);
                        cmdList.add(cmd);
                        verbList.add(verb);
                      }
                  }
              }
          }
      }
    CommandInfo[] cmds = new CommandInfo[cmdList.size()];
    cmdList.toArray(cmds);
    return cmds;
  }
 
  /**
   * Returns all commands for the given MIME type.
   * @param mimeType the MIME type
   */
  public synchronized CommandInfo[] getAllCommands(String mimeType)
  {
    List<CommandInfo> cmdList = new ArrayList<CommandInfo>();
    for (int i = 0; i < 2; i++)
      {
        for (int j = 0; j < 5; j++)
          {
            Map<String,List<String>> map = getCommands(mailcaps[j][i], mimeType);
            if (map != null)
              {
                for (Map.Entry<String,List<String>> entry : map.entrySet())
                  {
                    String verb = entry.getKey();
                    List<String> classNames = entry.getValue();
                    int len = classNames.size();
                    for (int l = 0; l < len; l++)
                      {
                        String className = classNames.get(l);
                        CommandInfo cmd = new CommandInfo(verb, className);
                        cmdList.add(cmd);
                      }
                  }
              }
          }
      }
    CommandInfo[] cmds = new CommandInfo[cmdList.size()];
    cmdList.toArray(cmds);
    return cmds;
  }
 
  /**
   * Returns the command with the specified name for the given MIME type.
   * @param mimeType the MIME type
   * @param cmdName the command verb
   */
  public synchronized CommandInfo getCommand(String mimeType,
                                             String cmdName)
  {
    for (int i = 0; i < 2; i++)
      {
        for (int j = 0; j < 5; j++)
          {
            Map<String,List<String>> map =
              getCommands(mailcaps[j][i], mimeType);
            if (map != null)
              {
                List<String> classNames = map.get(cmdName);
                if (classNames == null)
                  {
                    classNames = map.get("x-java-" + cmdName);
                  }
                if (classNames != null)
                  {
                    String className = classNames.get(0);
                    return new CommandInfo(cmdName, className);
                  }
              }
          }
      }
    return null;
  }
 
  /**
   * Adds entries programmatically to the registry.
   * @param mailcap a mailcap string
   */
  public synchronized void addMailcap(String mailcap)
  {
    if (debug)
      {
        System.out.println("MailcapCommandMap: add to PROG");
      }
    try
      {
        parse(PROG, new StringReader(mailcap));
      }
    catch (IOException e)
      {
      }
  }
 
  /**
   * Returns the DCH for the specified MIME type.
   * @param mimeType the MIME type
   */
  public synchronized DataContentHandler
    createDataContentHandler(String mimeType)
  {
    if (debug)
      {
        System.out.println("MailcapCommandMap: " +
                           "createDataContentHandler for " + mimeType);
      }
    for (int i = 0; i < 2; i++)
      {
        for (int j = 0; j < 5; j++)
          {
            if (debug)
              {
                System.out.println("  search DB #" + i);
              }
            Map<String,List<String>> map = getCommands(mailcaps[j][i], mimeType);
            if (map != null)
              {
                List<String> classNames = map.get("content-handler");
                if (classNames == null)
                  {
                    classNames = map.get("x-java-content-handler");
                  }
                if (classNames != null)
                  {
                    String className = classNames.get(0);
                    if (debug)
                      {
                        System.out.println("  In " + nameOf(j) +
                                           ", content-handler=" + className);
                      }
                    try
                      {
                        Class<?> clazz = Class.forName(className);
                        return (DataContentHandler)clazz.newInstance();
                      }
                    catch (IllegalAccessException e)
                      {
                        if (debug)
                          {
                            e.printStackTrace();
                          }
                      }
                    catch (ClassNotFoundException e)
                      {
                        if (debug)
                      {
                        e.printStackTrace();
                      }
                      }
                    catch (InstantiationException e)
                      {
                        if (debug)
                          {
                            e.printStackTrace();
                          }
                      }
                  }
              }
          }
      }
    return null;
  }
 
  /**
   * Get the native commands for the given MIME type.
   * Returns an array of strings where each string is
   * an entire mailcap file entry.  The application
   * will need to parse the entry to extract the actual
   * command as well as any attributes it needs. See
   * <a href="http://www.ietf.org/rfc/rfc1524.txt">RFC 1524</a>
   * for details of the mailcap entry syntax.  Only mailcap
   * entries that specify a view command for the specified
   * MIME type are returned.
   * @return array of native command entries
   * @since JAF 1.1
   */
  public String[] getNativeCommands(String mimeType)
  {
    List<String> acc = new ArrayList<String>();
    for (int i = 0; i < 2; i++)
      {
        for (int j = 0; j < 5; j++)
          {
            addNativeCommands(acc, mailcaps[j][i], mimeType);
          }
      }
    String[] ret = new String[acc.size()];
    acc.toArray(ret);
    return ret;
  }
 
  private void addNativeCommands(List<String> acc,
                                 Map<String,Map<String,List<String>>> mailcap,
                                 String mimeType)
  {
    for (Map.Entry<String,Map<String,List<String>>> mEntry : mailcap.entrySet())
      {
        String entryMimeType = mEntry.getKey();
        if (!entryMimeType.equals(mimeType))
          {
            continue;
          }
        Map<String,List<String>> commands = mEntry.getValue();
        String viewCommand = commands.get("view-command").get(0);
        if (viewCommand == null)
          {
            continue;
          }
        CPStringBuilder buf = new CPStringBuilder();
        buf.append(mimeType);
        buf.append(';');
        buf.append(' ');
        buf.append(viewCommand);
        for (Map.Entry<String,List<String>> cEntry : commands.entrySet())
          {
            String verb = cEntry.getKey();
            List<String> classNames = cEntry.getValue();
            if (!"view-command".equals(verb))
              {
                for (String command : classNames)
                  {
                    buf.append(';');
                    buf.append(' ');
                    buf.append(verb);
                    buf.append('=');
                    buf.append(command);
                  }
              }
          }
        if (buf.length() > 0)
          {
            acc.add(buf.toString());
          }
      }
  }
 
  private static String nameOf(int mailcap)
  {
    switch (mailcap)
      {
      case PROG:
        return "PROG";
      case HOME:
        return "HOME";
      case SYS:
        return "SYS";
      case JAR:
        return "JAR";
      case DEF:
        return "DEF";
      default:
        return "ERR";
      }
  }
 
  private void parseFile(int index, String filename)
  {
    Reader in = null;
    try
      {
        if (debug)
          {
            System.out.println("\t" + filename);
          }
        in = new FileReader(filename);
        parse(index, in);
      }
    catch (IOException e)
      {
        if (debug)
          {
            System.out.println(e.getClass().getName() + ": " +
                               e.getMessage());
          }
      }
    finally
      {
        if (in != null)
          {
            try
              {
                in.close();
              }
            catch (IOException e)
              {
              }
          }
      }
  }
 
  private void parseResource(int index, String name)
  {
    Reader in = null;
    try
      {
        InputStream is = getClass().getResourceAsStream(name);
        if (is != null)
          {
            if (debug)
              {
                System.out.println("\t" + name);
              }
            in = new InputStreamReader(is);
            parse(index, in);
          }
      }
    catch (IOException e)
      {
        if (debug)
          {
            System.out.println(e.getClass().getName() + ": " +
                               e.getMessage());
          }
      }
    finally
      {
        if (in != null)
          {
            try
              {
                in.close();
              }
            catch (IOException e)
              {
              }
          }
      }
  }
 
  private void parse(int index, Reader in)
    throws IOException
  {
    BufferedReader br = new BufferedReader(in);
    CPStringBuilder buf = null;
    for (String line = br.readLine(); line != null; line = br.readLine())
      {
        line = line.trim();
        int len = line.length();
        if (len == 0 || line.charAt(0) == '#')
          {
            continue; // Comment
          }
        if (line.charAt(len - 1) == '\\')
          {
            if (buf == null)
              {
                buf = new CPStringBuilder();
              }
            buf.append(line.substring(0, len - 1));
          }
        else if (buf != null)
          {
            buf.append(line);
            parseEntry(index, buf.toString());
            buf = null;
          }
        else
          {
            parseEntry(index, line);
          }
      }
  }
 
  private void parseEntry(int index, String line)
  {
    // Tokenize entry into fields
    char[] chars = line.toCharArray();
    int len = chars.length;
    boolean inQuotedString = false;
    boolean fallback = false;
    CPStringBuilder buffer = new CPStringBuilder();
    List<String> fields = new ArrayList<String>();
    for (int i = 0; i < len; i++)
      {
        char c = chars[i];
        if (c == '\\')
          {
            c = chars[++i]; // qchar
          }
        if (c == ';' && !inQuotedString)
          {
            String field = buffer.toString().trim();
            if ("x-java-fallback-entry".equals(field))
              {
                fallback = true;
              }
            fields.add(field);
            buffer.setLength(0);
          }
        else
          {
            if (c == '"')
              {
                inQuotedString = !inQuotedString;
              }
            buffer.append(c);
          }
      }
    String field = buffer.toString().trim();
    if ("x-java-fallback-entry".equals(field))
      {
        fallback = true;
      }
    fields.add(field);
 
    len = fields.size();
    if (len < 2)
      {
        if (debug)
          {
            System.err.println("Invalid mailcap entry: " + line);
          }
        return;
      }
 
    Map<String,Map<String,List<String>>> mailcap =
      fallback ? mailcaps[index][FALLBACK] : mailcaps[index][NORMAL];
    String mimeType = fields.get(0);
    addField(mailcap, mimeType, "view-command", (String) fields.get(1));
    for (int i = 2; i < len; i++)
      {
        addField(mailcap, mimeType, null, (String) fields.get(i));
      }
  }
 
  private void addField(Map<String,Map<String,List<String>>> mailcap,
                        String mimeType, String verb, String command)
  {
    if (verb == null)
      {
        int ei = command.indexOf('=');
        if (ei != -1)
          {
            verb = command.substring(0, ei);
            command = command.substring(ei + 1);
          }
      }
    if (command.length() == 0 || verb == null || verb.length() == 0)
      {
        return; // Invalid field or flag
      }
 
    Map<String,List<String>> commands = mailcap.get(mimeType);
    if (commands == null)
      {
        commands = new LinkedHashMap<String,List<String>>();
        mailcap.put(mimeType, commands);
      }
    List<String> classNames = commands.get(verb);
    if (classNames == null)
      {
        classNames = new ArrayList<String>();
        commands.put(verb, classNames);
      }
    classNames.add(command);
  }
 
  private Map<String,List<String>>
    getCommands(Map<String,Map<String,List<String>>> mailcap,
                String mimeType)
  {
    int si = mimeType.indexOf('/');
    String genericMimeType = new CPStringBuilder(mimeType.substring(0, si))
      .append('/')
      .append('*')
      .toString();
    Map<String,List<String>> specific = mailcap.get(mimeType);
    Map<String,List<String>> generic = mailcap.get(genericMimeType);
    if (generic == null)
      {
        return specific;
      }
    if (specific == null)
      {
        return generic;
      }
    Map<String,List<String>> combined = new LinkedHashMap<String,List<String>>();
    combined.putAll(specific);
    for (String verb : generic.keySet())
      {
        List<String> genericClassNames = generic.get(verb);
        List<String> classNames = combined.get(verb);
        if (classNames == null)
          {
            combined.put(verb, genericClassNames);
          }
        else
          {
            classNames.addAll(genericClassNames);
          }
      }
    return combined;
  }
 
  // -- Utility methods --
 
  private List<URL> getSystemResources(String name)
  {
    List<URL> acc = new ArrayList<URL>();
    try
      {
        for (Enumeration<URL> i = ClassLoader.getSystemResources(name);
             i.hasMoreElements(); )
          {
            acc.add(i.nextElement());
          }
      }
    catch (IOException e)
      {
      }
    return acc;
  }
 
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [javax/] [activation/] [MailcapCommandMap.java] - Blame information for rev 772

Line No.	Rev	Author	Line
1	772	jeremybenn	`/* MailcapCommandMap.java -- Command map implementation using a mailcap file.`
2			`Copyright (C) 2004 Free Software Foundation, Inc.`
3
4			`This file is part of GNU Classpath.`
5
6			`GNU Classpath is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 2, or (at your option)`
9			`any later version.`
10
11			`GNU Classpath is distributed in the hope that it will be useful, but`
12			`WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
14			`General Public License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with GNU Classpath; see the file COPYING. If not, write to the`
18			`Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA`
19			`02110-1301 USA.`
20
21			`Linking this library statically or dynamically with other modules is`
22			`making a combined work based on this library. Thus, the terms and`
23			`conditions of the GNU General Public License cover the whole`
24			`combination.`
25
26			`As a special exception, the copyright holders of this library give you`
27			`permission to link this library with independent modules to produce an`
28			`executable, regardless of the license terms of these independent`
29			`modules, and to copy and distribute the resulting executable under`
30			`terms of your choice, provided that you also meet, for each linked`
31			`independent module, the terms and conditions of the license of that`
32			`module. An independent module is a module which is not derived from`
33			`or based on this library. If you modify this library, you may extend`
34			`this exception to your version of the library, but you are not`
35			`obligated to do so. If you do not wish to do so, delete this`
36			`exception statement from your version. */`
37
38			`package javax.activation;`
39
40			`import gnu.java.lang.CPStringBuilder;`
41
42			`import java.io.BufferedReader;`
43			`import java.io.File;`
44			`import java.io.FileReader;`
45			`import java.io.InputStream;`
46			`import java.io.InputStreamReader;`
47			`import java.io.IOException;`
48			`import java.io.Reader;`
49			`import java.io.StringReader;`
50			`import java.net.URL;`
51			`import java.util.ArrayList;`
52			`import java.util.Enumeration;`
53			`import java.util.LinkedHashMap;`
54			`import java.util.Iterator;`
55			`import java.util.List;`
56			`import java.util.Map;`
57
58			`/**`
59			`* Implementation of a command map using a <code>mailcap</code> file (RFC`
60			`* 1524). Mailcap files are searched for in the following places:`
61			`* <ol>`
62			`* <li>Programmatically added entries to this interface</li>`
63			`* <li>the file <tt>.mailcap</tt> in the user's home directory</li>`
64			`* <li>the file <i><java.home></i><tt>/lib/mailcap</tt></li>`
65			`* <li>the resource <tt>META-INF/mailcap</tt></li>`
66			`* <li>the resource <tt>META-INF/mailcap.default</tt> in the JAF`
67			`* distribution</li>`
68			`* </ol>`
69			`*`
70			`* @author <a href='mailto:dog@gnu.org'>Chris Burdess</a>`
71			`* @version 1.1`
72			`*/`
73			`public class MailcapCommandMap`
74			`extends CommandMap`
75			`{`
76
77			`private static final int PROG = 0;`
78			`private static final int HOME = 1;`
79			`private static final int SYS = 2;`
80			`private static final int JAR = 3;`
81			`private static final int DEF = 4;`
82			`private static boolean debug = false;`
83			`private static final int NORMAL = 0;`
84			`private static final int FALLBACK = 1;`
85
86			`static`
87			`{`
88			`try`
89			`{`
90			`String d = System.getProperty("javax.activation.debug");`
91			`debug = Boolean.valueOf(d).booleanValue();`
92			`}`
93			`catch (SecurityException e)`
94			`{`
95			`}`
96			`}`
97
98			`private Map<String,Map<String,List<String>>>[][] mailcaps;`
99
100			`/**`
101			`* Default constructor.`
102			`*/`
103			`public MailcapCommandMap()`
104			`{`
105			`init(null);`
106			`}`
107
108			`/**`
109			`* Constructor specifying a filename.`
110			`* @param fileName the name of the file to read mailcap entries from`
111			`*/`
112			`public MailcapCommandMap(String fileName)`
113			`throws IOException`
114			`{`
115			`Reader in = null;`
116			`try`
117			`{`
118			`in = new FileReader(fileName);`
119			`}`
120			`catch (IOException e)`
121			`{`
122			`}`
123			`init(in);`
124			`if (in != null)`
125			`{`
126			`try`
127			`{`
128			`in.close();`
129			`}`
130			`catch (IOException e)`
131			`{`
132			`}`
133			`}`
134			`}`
135
136			`/**`
137			`* Constructor specifying an input stream.`
138			`* @param is the input stream to read mailcap entries from`
139			`*/`
140			`public MailcapCommandMap(InputStream is)`
141			`{`
142			`init(new InputStreamReader(is));`
143			`}`
144
145			`private void init(Reader in)`
146			`{`
147			`mailcaps = new Map[5][2];`
148			`for (int i = 0; i < 5; i++)`
149			`{`
150			`for (int j = 0; j < 2; j++)`
151			`{`
152			`mailcaps[i][j] =`
153			`new LinkedHashMap<String,Map<String,List<String>>>();`
154			`}`
155			`}`
156			`if (in != null)`
157			`{`
158			`if (debug)`
159			`{`
160			`System.out.println("MailcapCommandMap: load PROG");`
161			`}`
162			`try`
163			`{`
164			`parse(PROG, in);`
165			`}`
166			`catch (IOException e)`
167			`{`
168			`}`
169			`}`
170
171			`if (debug)`
172			`{`
173			`System.out.println("MailcapCommandMap: load HOME");`
174			`}`
175			`try`
176			`{`
177			`String home = System.getProperty("user.home");`
178			`if (home != null)`
179			`{`
180			`parseFile(HOME, new CPStringBuilder(home)`
181			`.append(File.separatorChar)`
182			`.append(".mailcap")`
183			`.toString());`
184			`}`
185			`}`
186			`catch (SecurityException e)`
187			`{`
188			`}`
189
190			`if (debug)`
191			`{`
192			`System.out.println("MailcapCommandMap: load SYS");`
193			`}`
194			`try`
195			`{`
196			`parseFile(SYS,`
197			`new CPStringBuilder(System.getProperty("java.home"))`
198			`.append(File.separatorChar)`
199			`.append("lib")`
200			`.append(File.separatorChar)`
201			`.append("mailcap")`
202			`.toString());`
203			`}`
204			`catch (SecurityException e)`
205			`{`
206			`}`
207
208			`if (debug)`
209			`{`
210			`System.out.println("MailcapCommandMap: load JAR");`
211			`}`
212			`List<URL> systemResources = getSystemResources("META-INF/mailcap");`
213			`int len = systemResources.size();`
214			`if (len > 0)`
215			`{`
216			`for (int i = 0; i < len ; i++)`
217			`{`
218			`Reader urlIn = null;`
219			`URL url = systemResources.get(i);`
220			`try`
221			`{`
222			`if (debug)`
223			`{`
224			`System.out.println("\t" + url.toString());`
225			`}`
226			`urlIn = new InputStreamReader(url.openStream());`
227			`parse(JAR, urlIn);`
228			`}`
229			`catch (IOException e)`
230			`{`
231			`if (debug)`
232			`{`
233			`System.out.println(e.getClass().getName() + ": " +`
234			`e.getMessage());`
235			`}`
236			`}`
237			`finally`
238			`{`
239			`if (urlIn != null)`
240			`{`
241			`try`
242			`{`
243			`urlIn.close();`
244			`}`
245			`catch (IOException e)`
246			`{`
247			`}`
248			`}`
249			`}`
250			`}`
251			`}`
252			`else`
253			`{`
254			`parseResource(JAR, "/META-INF/mailcap");`
255			`}`
256
257			`if (debug)`
258			`{`
259			`System.out.println("MailcapCommandMap: load DEF");`
260			`}`
261			`parseResource(DEF, "/META-INF/mailcap.default");`
262			`}`
263
264			`/**`
265			`* Returns the list of preferred commands for a given MIME type.`
266			`* @param mimeType the MIME type`
267			`*/`
268			`public synchronized CommandInfo[] getPreferredCommands(String mimeType)`
269			`{`
270			`List<CommandInfo> cmdList = new ArrayList<CommandInfo>();`
271			`List<String> verbList = new ArrayList<String>();`
272			`for (int i = 0; i < 2; i++)`
273			`{`
274			`for (int j = 0; j < 5; j++)`
275			`{`
276			`Map<String,List<String>> map = getCommands(mailcaps[j][i], mimeType);`
277			`if (map != null)`
278			`{`
279			`for (Map.Entry<String,List<String>> entry : map.entrySet())`
280			`{`
281			`String verb = entry.getKey();`
282			`if (!verbList.contains(verb))`
283			`{`
284			`List<String> classNames = entry.getValue();`
285			`String className = classNames.get(0);`
286			`CommandInfo cmd = new CommandInfo(verb, className);`
287			`cmdList.add(cmd);`
288			`verbList.add(verb);`
289			`}`
290			`}`
291			`}`
292			`}`
293			`}`
294			`CommandInfo[] cmds = new CommandInfo[cmdList.size()];`
295			`cmdList.toArray(cmds);`
296			`return cmds;`
297			`}`
298
299			`/**`
300			`* Returns all commands for the given MIME type.`
301			`* @param mimeType the MIME type`
302			`*/`
303			`public synchronized CommandInfo[] getAllCommands(String mimeType)`
304			`{`
305			`List<CommandInfo> cmdList = new ArrayList<CommandInfo>();`
306			`for (int i = 0; i < 2; i++)`
307			`{`
308			`for (int j = 0; j < 5; j++)`
309			`{`
310			`Map<String,List<String>> map = getCommands(mailcaps[j][i], mimeType);`
311			`if (map != null)`
312			`{`
313			`for (Map.Entry<String,List<String>> entry : map.entrySet())`
314			`{`
315			`String verb = entry.getKey();`
316			`List<String> classNames = entry.getValue();`
317			`int len = classNames.size();`
318			`for (int l = 0; l < len; l++)`
319			`{`
320			`String className = classNames.get(l);`
321			`CommandInfo cmd = new CommandInfo(verb, className);`
322			`cmdList.add(cmd);`
323			`}`
324			`}`
325			`}`
326			`}`
327			`}`
328			`CommandInfo[] cmds = new CommandInfo[cmdList.size()];`
329			`cmdList.toArray(cmds);`
330			`return cmds;`
331			`}`
332
333			`/**`
334			`* Returns the command with the specified name for the given MIME type.`
335			`* @param mimeType the MIME type`
336			`* @param cmdName the command verb`
337			`*/`
338			`public synchronized CommandInfo getCommand(String mimeType,`
339			`String cmdName)`
340			`{`
341			`for (int i = 0; i < 2; i++)`
342			`{`
343			`for (int j = 0; j < 5; j++)`
344			`{`
345			`Map<String,List<String>> map =`
346			`getCommands(mailcaps[j][i], mimeType);`
347			`if (map != null)`
348			`{`
349			`List<String> classNames = map.get(cmdName);`
350			`if (classNames == null)`
351			`{`
352			`classNames = map.get("x-java-" + cmdName);`
353			`}`
354			`if (classNames != null)`
355			`{`
356			`String className = classNames.get(0);`
357			`return new CommandInfo(cmdName, className);`
358			`}`
359			`}`
360			`}`
361			`}`
362			`return null;`
363			`}`
364
365			`/**`
366			`* Adds entries programmatically to the registry.`
367			`* @param mailcap a mailcap string`
368			`*/`
369			`public synchronized void addMailcap(String mailcap)`
370			`{`
371			`if (debug)`
372			`{`
373			`System.out.println("MailcapCommandMap: add to PROG");`
374			`}`
375			`try`
376			`{`
377			`parse(PROG, new StringReader(mailcap));`
378			`}`
379			`catch (IOException e)`
380			`{`
381			`}`
382			`}`
383
384			`/**`
385			`* Returns the DCH for the specified MIME type.`
386			`* @param mimeType the MIME type`
387			`*/`
388			`public synchronized DataContentHandler`
389			`createDataContentHandler(String mimeType)`
390			`{`
391			`if (debug)`
392			`{`
393			`System.out.println("MailcapCommandMap: " +`
394			`"createDataContentHandler for " + mimeType);`
395			`}`
396			`for (int i = 0; i < 2; i++)`
397			`{`
398			`for (int j = 0; j < 5; j++)`
399			`{`
400			`if (debug)`
401			`{`
402			`System.out.println(" search DB #" + i);`
403			`}`
404			`Map<String,List<String>> map = getCommands(mailcaps[j][i], mimeType);`
405			`if (map != null)`
406			`{`
407			`List<String> classNames = map.get("content-handler");`
408			`if (classNames == null)`
409			`{`
410			`classNames = map.get("x-java-content-handler");`
411			`}`
412			`if (classNames != null)`
413			`{`
414			`String className = classNames.get(0);`
415			`if (debug)`
416			`{`
417			`System.out.println(" In " + nameOf(j) +`
418			`", content-handler=" + className);`
419			`}`
420			`try`
421			`{`
422			`Class<?> clazz = Class.forName(className);`
423			`return (DataContentHandler)clazz.newInstance();`
424			`}`
425			`catch (IllegalAccessException e)`
426			`{`
427			`if (debug)`
428			`{`
429			`e.printStackTrace();`
430			`}`
431			`}`
432			`catch (ClassNotFoundException e)`
433			`{`
434			`if (debug)`
435			`{`
436			`e.printStackTrace();`
437			`}`
438			`}`
439			`catch (InstantiationException e)`
440			`{`
441			`if (debug)`
442			`{`
443			`e.printStackTrace();`
444			`}`
445			`}`
446			`}`
447			`}`
448			`}`
449			`}`
450			`return null;`
451			`}`
452
453			`/**`
454			`* Get the native commands for the given MIME type.`
455			`* Returns an array of strings where each string is`
456			`* an entire mailcap file entry. The application`
457			`* will need to parse the entry to extract the actual`
458			`* command as well as any attributes it needs. See`
459			`* <a href="http://www.ietf.org/rfc/rfc1524.txt">RFC 1524</a>`
460			`* for details of the mailcap entry syntax. Only mailcap`
461			`* entries that specify a view command for the specified`
462			`* MIME type are returned.`
463			`* @return array of native command entries`
464			`* @since JAF 1.1`
465			`*/`
466			`public String[] getNativeCommands(String mimeType)`
467			`{`
468			`List<String> acc = new ArrayList<String>();`
469			`for (int i = 0; i < 2; i++)`
470			`{`
471			`for (int j = 0; j < 5; j++)`
472			`{`
473			`addNativeCommands(acc, mailcaps[j][i], mimeType);`
474			`}`
475			`}`
476			`String[] ret = new String[acc.size()];`
477			`acc.toArray(ret);`
478			`return ret;`
479			`}`
480
481			`private void addNativeCommands(List<String> acc,`
482			`Map<String,Map<String,List<String>>> mailcap,`
483			`String mimeType)`
484			`{`
485			`for (Map.Entry<String,Map<String,List<String>>> mEntry : mailcap.entrySet())`
486			`{`
487			`String entryMimeType = mEntry.getKey();`
488			`if (!entryMimeType.equals(mimeType))`
489			`{`
490			`continue;`
491			`}`
492			`Map<String,List<String>> commands = mEntry.getValue();`
493			`String viewCommand = commands.get("view-command").get(0);`
494			`if (viewCommand == null)`
495			`{`
496			`continue;`
497			`}`
498			`CPStringBuilder buf = new CPStringBuilder();`
499			`buf.append(mimeType);`
500			`buf.append(';');`
501			`buf.append(' ');`
502			`buf.append(viewCommand);`
503			`for (Map.Entry<String,List<String>> cEntry : commands.entrySet())`
504			`{`
505			`String verb = cEntry.getKey();`
506			`List<String> classNames = cEntry.getValue();`
507			`if (!"view-command".equals(verb))`
508			`{`
509			`for (String command : classNames)`
510			`{`
511			`buf.append(';');`
512			`buf.append(' ');`
513			`buf.append(verb);`
514			`buf.append('=');`
515			`buf.append(command);`
516			`}`
517			`}`
518			`}`
519			`if (buf.length() > 0)`
520			`{`
521			`acc.add(buf.toString());`
522			`}`
523			`}`
524			`}`
525
526			`private static String nameOf(int mailcap)`
527			`{`
528			`switch (mailcap)`
529			`{`
530			`case PROG:`
531			`return "PROG";`
532			`case HOME:`
533			`return "HOME";`
534			`case SYS:`
535			`return "SYS";`
536			`case JAR:`
537			`return "JAR";`
538			`case DEF:`
539			`return "DEF";`
540			`default:`
541			`return "ERR";`
542			`}`
543			`}`
544
545			`private void parseFile(int index, String filename)`
546			`{`
547			`Reader in = null;`
548			`try`
549			`{`
550			`if (debug)`
551			`{`
552			`System.out.println("\t" + filename);`
553			`}`
554			`in = new FileReader(filename);`
555			`parse(index, in);`
556			`}`
557			`catch (IOException e)`
558			`{`
559			`if (debug)`
560			`{`
561			`System.out.println(e.getClass().getName() + ": " +`
562			`e.getMessage());`
563			`}`
564			`}`
565			`finally`
566			`{`
567			`if (in != null)`
568			`{`
569			`try`
570			`{`
571			`in.close();`
572			`}`
573			`catch (IOException e)`
574			`{`
575			`}`
576			`}`
577			`}`
578			`}`
579
580			`private void parseResource(int index, String name)`
581			`{`
582			`Reader in = null;`
583			`try`
584			`{`
585			`InputStream is = getClass().getResourceAsStream(name);`
586			`if (is != null)`
587			`{`
588			`if (debug)`
589			`{`
590			`System.out.println("\t" + name);`
591			`}`
592			`in = new InputStreamReader(is);`
593			`parse(index, in);`
594			`}`
595			`}`
596			`catch (IOException e)`
597			`{`
598			`if (debug)`
599			`{`
600			`System.out.println(e.getClass().getName() + ": " +`
601			`e.getMessage());`
602			`}`
603			`}`
604			`finally`
605			`{`
606			`if (in != null)`
607			`{`
608			`try`
609			`{`
610			`in.close();`
611			`}`
612			`catch (IOException e)`
613			`{`
614			`}`
615			`}`
616			`}`
617			`}`
618
619			`private void parse(int index, Reader in)`
620			`throws IOException`
621			`{`
622			`BufferedReader br = new BufferedReader(in);`
623			`CPStringBuilder buf = null;`
624			`for (String line = br.readLine(); line != null; line = br.readLine())`
625			`{`
626			`line = line.trim();`
627			`int len = line.length();`
628			`if (len == 0 \|\| line.charAt(0) == '#')`
629			`{`
630			`continue; // Comment`
631			`}`
632			`if (line.charAt(len - 1) == '\\')`
633			`{`
634			`if (buf == null)`
635			`{`
636			`buf = new CPStringBuilder();`
637			`}`
638			`buf.append(line.substring(0, len - 1));`
639			`}`
640			`else if (buf != null)`
641			`{`
642			`buf.append(line);`
643			`parseEntry(index, buf.toString());`
644			`buf = null;`
645			`}`
646			`else`
647			`{`
648			`parseEntry(index, line);`
649			`}`
650			`}`
651			`}`
652
653			`private void parseEntry(int index, String line)`
654			`{`
655			`// Tokenize entry into fields`
656			`char[] chars = line.toCharArray();`
657			`int len = chars.length;`
658			`boolean inQuotedString = false;`
659			`boolean fallback = false;`
660			`CPStringBuilder buffer = new CPStringBuilder();`
661			`List<String> fields = new ArrayList<String>();`
662			`for (int i = 0; i < len; i++)`
663			`{`
664			`char c = chars[i];`
665			`if (c == '\\')`
666			`{`
667			`c = chars[++i]; // qchar`
668			`}`
669			`if (c == ';' && !inQuotedString)`
670			`{`
671			`String field = buffer.toString().trim();`
672			`if ("x-java-fallback-entry".equals(field))`
673			`{`
674			`fallback = true;`
675			`}`
676			`fields.add(field);`
677			`buffer.setLength(0);`
678			`}`
679			`else`
680			`{`
681			`if (c == '"')`
682			`{`
683			`inQuotedString = !inQuotedString;`
684			`}`
685			`buffer.append(c);`
686			`}`
687			`}`
688			`String field = buffer.toString().trim();`
689			`if ("x-java-fallback-entry".equals(field))`
690			`{`
691			`fallback = true;`
692			`}`
693			`fields.add(field);`
694
695			`len = fields.size();`
696			`if (len < 2)`
697			`{`
698			`if (debug)`
699			`{`
700			`System.err.println("Invalid mailcap entry: " + line);`
701			`}`
702			`return;`
703			`}`
704
705			`Map<String,Map<String,List<String>>> mailcap =`
706			`fallback ? mailcaps[index][FALLBACK] : mailcaps[index][NORMAL];`
707			`String mimeType = fields.get(0);`
708			`addField(mailcap, mimeType, "view-command", (String) fields.get(1));`
709			`for (int i = 2; i < len; i++)`
710			`{`
711			`addField(mailcap, mimeType, null, (String) fields.get(i));`
712			`}`
713			`}`
714
715			`private void addField(Map<String,Map<String,List<String>>> mailcap,`
716			`String mimeType, String verb, String command)`
717			`{`
718			`if (verb == null)`
719			`{`
720			`int ei = command.indexOf('=');`
721			`if (ei != -1)`
722			`{`
723			`verb = command.substring(0, ei);`
724			`command = command.substring(ei + 1);`
725			`}`
726			`}`
727			`if (command.length() == 0 \|\| verb == null \|\| verb.length() == 0)`
728			`{`
729			`return; // Invalid field or flag`
730			`}`
731
732			`Map<String,List<String>> commands = mailcap.get(mimeType);`
733			`if (commands == null)`
734			`{`
735			`commands = new LinkedHashMap<String,List<String>>();`
736			`mailcap.put(mimeType, commands);`
737			`}`
738			`List<String> classNames = commands.get(verb);`
739			`if (classNames == null)`
740			`{`
741			`classNames = new ArrayList<String>();`
742			`commands.put(verb, classNames);`
743			`}`
744			`classNames.add(command);`
745			`}`
746
747			`private Map<String,List<String>>`
748			`getCommands(Map<String,Map<String,List<String>>> mailcap,`
749			`String mimeType)`
750			`{`
751			`int si = mimeType.indexOf('/');`
752			`String genericMimeType = new CPStringBuilder(mimeType.substring(0, si))`
753			`.append('/')`
754			`.append('*')`
755			`.toString();`
756			`Map<String,List<String>> specific = mailcap.get(mimeType);`
757			`Map<String,List<String>> generic = mailcap.get(genericMimeType);`
758			`if (generic == null)`
759			`{`
760			`return specific;`
761			`}`
762			`if (specific == null)`
763			`{`
764			`return generic;`
765			`}`
766			`Map<String,List<String>> combined = new LinkedHashMap<String,List<String>>();`
767			`combined.putAll(specific);`
768			`for (String verb : generic.keySet())`
769			`{`
770			`List<String> genericClassNames = generic.get(verb);`
771			`List<String> classNames = combined.get(verb);`
772			`if (classNames == null)`
773			`{`
774			`combined.put(verb, genericClassNames);`
775			`}`
776			`else`
777			`{`
778			`classNames.addAll(genericClassNames);`
779			`}`
780			`}`
781			`return combined;`
782			`}`
783
784			`// -- Utility methods --`
785
786			`private List<URL> getSystemResources(String name)`
787			`{`
788			`List<URL> acc = new ArrayList<URL>();`
789			`try`
790			`{`
791			`for (Enumeration<URL> i = ClassLoader.getSystemResources(name);`
792			`i.hasMoreElements(); )`
793			`{`
794			`acc.add(i.nextElement());`
795			`}`
796			`}`
797			`catch (IOException e)`
798			`{`
799			`}`
800			`return acc;`
801			`}`
802
803			`}`