Import GNU JAF.

2008-08-17  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* gnu/javax/activation/viewers/ImageViewer.java,
	* gnu/javax/activation/viewers/TextEditor.java,
	* gnu/javax/activation/viewers/TextViewer.java,
	* javax/activation/ActivationDataFlavor.java,
	* javax/activation/CommandInfo.java,
	* javax/activation/CommandMap.java,
	* javax/activation/CommandObject.java,
	* javax/activation/DataContentHandler.java,
	* javax/activation/DataContentHandlerFactory.java,
	* javax/activation/DataHandler.java,
	* javax/activation/DataHandlerDataSource.java,
	* javax/activation/DataSource.java,
	* javax/activation/DataSourceDataContentHandler.java,
	* javax/activation/FileDataSource.java,
	* javax/activation/FileTypeMap.java,
	* javax/activation/MailcapCommandMap.java,
	* javax/activation/MimeType.java,
	* javax/activation/MimeTypeParameterList.java,
	* javax/activation/MimeTypeParseException.java,
	* javax/activation/MimetypesFileTypeMap.java,
	* javax/activation/ObjectDataContentHandler.java,
	* javax/activation/URLDataSource.java,
	* javax/activation/UnsupportedDataTypeException.java,
	* javax/activation/package.html,
	* resource/META-INF/mailcap.default,
	* resource/META-INF/mimetypes.default:
	Import GNU JAF CVS as of 17/08/2008.

2006-04-25  Archit Shah  <ashah@redhat.com>

	* javax/activation/MimeTypeParameterList.java:
	Insert ';' separator before parameter list.

2005-06-29  Xavier Poinsard  <xpoinsard@openpricer.com>

	* javax/activation/ObjectDataContentHandler.java:
	Fixed typo.

2005-05-28  Chris Burdess  <dog@bluezoo.org>

	* javax/activation/CommandMap.java,
	* javax/activation/MailcapCommandMap.java:
	Updated to JAF 1.1.

2004-06-09  Chris Burdess  <dog@bluezoo.org>

	* javax/activation/MailcapCommandMap.java:
	Fixed bug whereby x-java prefix was not
	attempted.

1 files changed, 801 insertions, 0 deletions

diff --git a/javax/activation/MailcapCommandMap.java b/javax/activation/MailcapCommandMap.java
new file mode 100644
index 000000000..0d2c8ec5c
--- /dev/null
+++ b/javax/activation/MailcapCommandMap.java
@@ -0,0 +1,801 @@
+/* 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 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[][] 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();
+          }
+      }
+    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 StringBuffer(home)
+                      .append(File.separatorChar)
+                      .append(".mailcap")
+                      .toString());
+          }
+      }
+    catch (SecurityException e)
+      {
+      }
+    
+    if (debug)
+      {
+        System.out.println("MailcapCommandMap: load SYS");
+      }
+    try
+      {
+        parseFile(SYS, 
+                  new StringBuffer(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 systemResources = getSystemResources("META-INF/mailcap");
+    int len = systemResources.size();
+    if (len > 0)
+      {
+        for (int i = 0; i < len ; i++)
+          {
+            Reader urlIn = null;
+            URL 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 cmdList = new ArrayList();
+    List verbList = new ArrayList();
+    for (int i = 0; i < 2; i++)
+      {
+        for (int j = 0; j < 5; j++)
+          {
+            Map map = getCommands(mailcaps[j][i], mimeType);
+            if (map != null)
+              {
+                for (Iterator k = map.entrySet().iterator(); k.hasNext(); )
+                  {
+                    Map.Entry entry = (Map.Entry) k.next();
+                    String verb = (String) entry.getKey();
+                    if (!verbList.contains(verb))
+                      {
+                        List classNames = (List) entry.getValue();
+                        String className = (String) 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 cmdList = new ArrayList();
+    for (int i = 0; i < 2; i++)
+      {
+        for (int j = 0; j < 5; j++)
+          {
+            Map map = getCommands(mailcaps[j][i], mimeType);
+            if (map != null)
+              {
+                for (Iterator k = map.entrySet().iterator(); k.hasNext(); )
+                  {
+                    Map.Entry entry = (Map.Entry) k.next();
+                    String verb = (String) entry.getKey();
+                    List classNames = (List) entry.getValue();
+                    int len = classNames.size();
+                    for (int l = 0; l < len; l++)
+                      {
+                        String className = (String) 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 map = getCommands(mailcaps[j][i], mimeType);
+            if (map != null)
+              {
+                List classNames = (List) map.get(cmdName);
+                if (classNames == null)
+                  {
+                    classNames = (List) map.get("x-java-" + cmdName);
+                  }
+                if (classNames != null)
+                  {
+                    String className = (String) classNames.get(0);
+                    return new CommandInfo(cmdName, className);
+                  }
+              }
+          }
+      }
+    return null;
+  }
+
+  /**
+   * Adds entries programmatically to the registry.
+   * @param mail_cap a mailcap string
+   */
+  public synchronized void addMailcap(String mail_cap)
+  {
+    if (debug)
+      {
+        System.out.println("MailcapCommandMap: add to PROG");
+      }
+    try
+      {
+        parse(PROG, new StringReader(mail_cap));
+      }
+    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 map = getCommands(mailcaps[j][i], mimeType);
+            if (map != null)
+              {
+                List classNames = (List) map.get("content-handler");
+                if (classNames == null)
+                  {
+                    classNames = (List) map.get("x-java-content-handler");
+                  }
+                if (classNames != null)
+                  {
+                    String className = (String) 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 acc = new ArrayList();
+    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 acc, Map mailcap, String mimeType)
+  {
+    for (Iterator j = mailcap.entrySet().iterator(); j.hasNext(); )
+      {
+        Map.Entry m_entry = (Map.Entry) j.next();
+        String entryMimeType = (String) m_entry.getKey();
+        if (!entryMimeType.equals(mimeType))
+          {
+            continue;
+          }
+        Map commands = (Map) m_entry.getValue();
+        String viewCommand = (String) commands.get("view-command");
+        if (viewCommand == null)
+          {
+            continue;
+          }
+        StringBuffer buf = new StringBuffer();
+        buf.append(mimeType);
+        buf.append(';');
+        buf.append(' ');
+        buf.append(viewCommand);
+        for (Iterator k = commands.entrySet().iterator(); k.hasNext(); )
+          {
+            Map.Entry c_entry = (Map.Entry) k.next();
+            String verb = (String) c_entry.getKey();
+            List classNames = (List) c_entry.getValue();
+            if (!"view-command".equals(verb))
+              {
+                for (Iterator l = classNames.iterator(); l.hasNext(); )
+                  {
+                    String command = (String) l.next();
+                    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);
+    StringBuffer 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 StringBuffer();
+              }
+            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;
+    StringBuffer buffer = new StringBuffer();
+    List fields = new ArrayList();
+    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 mailcap = fallback ? mailcaps[index][FALLBACK] :
+      mailcaps[index][NORMAL];
+    String mimeType = (String) 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 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 commands = (Map) mailcap.get(mimeType);
+    if (commands == null)
+      {
+        commands = new LinkedHashMap();
+        mailcap.put(mimeType, commands);
+      }
+    List classNames = (List) commands.get(verb);
+    if (classNames == null)
+      {
+        classNames = new ArrayList();
+        commands.put(verb, classNames);
+      }
+    classNames.add(command);
+  }
+  
+  private Map getCommands(Map mailcap, String mimeType)
+  {
+    int si = mimeType.indexOf('/');
+    String genericMimeType = new StringBuffer(mimeType.substring(0, si))
+      .append('/')
+      .append('*')
+      .toString();
+    Map specific = (Map) mailcap.get(mimeType);
+    Map generic = (Map) mailcap.get(genericMimeType);
+    if (generic == null)
+      {
+        return specific;
+      }
+    if (specific == null)
+      {
+        return generic;
+      }
+    Map combined = new LinkedHashMap();
+    combined.putAll(specific);
+    for (Iterator i = generic.keySet().iterator(); i.hasNext(); )
+      {
+        String verb = (String) i.next();
+        List genericClassNames = (List) generic.get(verb);
+        List classNames = (List) combined.get(verb);
+        if (classNames == null)
+          {
+            combined.put(verb, genericClassNames);
+          }
+        else
+          {
+            classNames.addAll(genericClassNames);
+          }
+      }
+    return combined;
+  }
+
+  // -- Utility methods --
+  
+  private List getSystemResources(String name)
+  {
+    List acc = new ArrayList();
+    try
+      {
+        for (Enumeration i = ClassLoader.getSystemResources(name);
+             i.hasMoreElements(); )
+          {
+            acc.add(i.nextElement());
+          }
+      }
+    catch (IOException e)
+      {
+      }
+    return acc;
+  }
+  
+}
+