W3C home > Mailing lists > Public > www-validator-cvs@w3.org > August 2012

2002/css-validator/org/w3c/www/mime MimeType.java,1.6,1.7

From: Yves Lafon via cvs-syncmail <cvsmail@w3.org>
Date: Sat, 04 Aug 2012 21:17:10 +0000
To: www-validator-cvs@w3.org
Message-Id: <E1Sxlig-0008Dn-0f@lionel-hutz.w3.org>
Update of /sources/public/2002/css-validator/org/w3c/www/mime
In directory hutz:/tmp/cvs-serv31218/w3c/www/mime

Modified Files:
	MimeType.java 
Log Message:
font revamp, still some missing properties for CSS3 and @font-face for CSS2 and CSS3

Index: MimeType.java
===================================================================
RCS file: /sources/public/2002/css-validator/org/w3c/www/mime/MimeType.java,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- MimeType.java	3 Apr 2012 14:20:54 -0000	1.6
+++ MimeType.java	4 Aug 2012 21:17:07 -0000	1.7
@@ -3,7 +3,7 @@
 // (c) COPYRIGHT MIT and INRIA, 1996.
 // Please first read the full copyright statement in file COPYRIGHT.html
 
-package org.w3c.www.mime ;
+package org.w3c.www.mime;
 
 import java.io.Serializable;
 import java.util.ArrayList;
@@ -15,432 +15,441 @@
  */
 
 public class MimeType implements Serializable, Cloneable {
-    /**
-     * List of well known MIME types:
-     */
-    public static MimeType TEXT_HTML                         = null ;
-    public static MimeType APPLICATION_POSTSCRIPT            = null ;
-    public static MimeType TEXT_PLAIN                        = null ;
-    public static MimeType APPLICATION_X_WWW_FORM_URLENCODED = null ;
-    public static MimeType APPLICATION_OCTET_STREAM          = null ;
-    public static MimeType MULTIPART_FORM_DATA               = null ;
-    public static MimeType APPLICATION_X_JAVA_AGENT          = null ;
-    public static MimeType MESSAGE_HTTP                      = null ;
-    public static MimeType TEXT_CSS                          = null ;
-    public static MimeType TEXT_XML                          = null ;
-    public static MimeType APPLICATION_XML                   = null ;
-    public static MimeType TEXT                              = null ;
-    public static MimeType APPLICATION_RDF_XML               = null ;
-    public static MimeType APPLICATION_XHTML_XML             = null ;
+	/**
+	 * List of well known MIME types:
+	 */
+	public static MimeType TEXT_HTML = null;
+	public static MimeType APPLICATION_POSTSCRIPT = null;
+	public static MimeType TEXT_PLAIN = null;
+	public static MimeType APPLICATION_X_WWW_FORM_URLENCODED = null;
+	public static MimeType APPLICATION_OCTET_STREAM = null;
+	public static MimeType MULTIPART_FORM_DATA = null;
+	public static MimeType APPLICATION_X_JAVA_AGENT = null;
+	public static MimeType MESSAGE_HTTP = null;
+	public static MimeType TEXT_CSS = null;
+	public static MimeType TEXT_XML = null;
+	public static MimeType APPLICATION_XML = null;
+	public static MimeType TEXT = null;
+	public static MimeType APPLICATION_RDF_XML = null;
+	public static MimeType APPLICATION_XHTML_XML = null;
 
-    public static String star = "*".intern();
+	public static String star = "*".intern();
 
-    static {
-	try {
-	    TEXT_HTML
-		= new MimeType("text/html");
-	    APPLICATION_POSTSCRIPT
-		= new MimeType ("application/postscript") ;
-	    TEXT_PLAIN
-		= new MimeType("text/plain") ;
-	    APPLICATION_X_WWW_FORM_URLENCODED
-		= new MimeType("application/x-www-form-urlencoded") ;
-	    APPLICATION_OCTET_STREAM
-		= new MimeType("application/octet-stream") ;
-	    MULTIPART_FORM_DATA
-		= new MimeType("multipart/form-data") ;
-	    APPLICATION_X_JAVA_AGENT
-		= new MimeType("application/x-java-agent") ;
-	    MESSAGE_HTTP
-		= new MimeType("message/http");
-	    TEXT_CSS
-		= new MimeType("text/css");
-	    TEXT_XML
-		= new MimeType("text/xml");
-	    TEXT
-		= new MimeType("text/*");
-	    APPLICATION_RDF_XML
-		= new MimeType("application/rdf+xml");
-	    APPLICATION_XHTML_XML
-		= new MimeType("application/xhtml+xml");
-            APPLICATION_XML
-                = new MimeType("application/xml");
-	} catch (MimeTypeFormatException e) {
-	    System.out.println ("httpd.MimeType: invalid static init.") ;
-	    System.exit (1) ;
+	static {
+		try {
+			TEXT_HTML
+					= new MimeType("text/html");
+			APPLICATION_POSTSCRIPT
+					= new MimeType("application/postscript");
+			TEXT_PLAIN
+					= new MimeType("text/plain");
+			APPLICATION_X_WWW_FORM_URLENCODED
+					= new MimeType("application/x-www-form-urlencoded");
+			APPLICATION_OCTET_STREAM
+					= new MimeType("application/octet-stream");
+			MULTIPART_FORM_DATA
+					= new MimeType("multipart/form-data");
+			APPLICATION_X_JAVA_AGENT
+					= new MimeType("application/x-java-agent");
+			MESSAGE_HTTP
+					= new MimeType("message/http");
+			TEXT_CSS
+					= new MimeType("text/css");
+			TEXT_XML
+					= new MimeType("text/xml");
+			TEXT
+					= new MimeType("text/*");
+			APPLICATION_RDF_XML
+					= new MimeType("application/rdf+xml");
+			APPLICATION_XHTML_XML
+					= new MimeType("application/xhtml+xml");
+			APPLICATION_XML
+					= new MimeType("application/xml");
+		} catch (MimeTypeFormatException e) {
+			System.out.println("httpd.MimeType: invalid static init.");
+			System.exit(1);
+		}
 	}
-    }
 
-    public final static int NO_MATCH               = -1 ;
-    public final static int MATCH_TYPE             =  1 ;
-    public final static int MATCH_SPECIFIC_TYPE    =  2 ;
-    public final static int MATCH_SUBTYPE          =  3 ;
-    public final static int MATCH_SPECIFIC_SUBTYPE =  4 ;
+	public final static int NO_MATCH = -1;
+	public final static int MATCH_TYPE = 1;
+	public final static int MATCH_SPECIFIC_TYPE = 2;
+	public final static int MATCH_SUBTYPE = 3;
+	public final static int MATCH_SPECIFIC_SUBTYPE = 4;
 
-    /**
-     * String representation of type
-     *
-     * @serial
-     */
-    protected String type      = null ;
-    /**
-     * String representation of subtype
-     *
-     * @serial
-     */
-    protected String subtype   = null ;
-    /**
-     * parameter names
-     *
-     * @serial
-     */
-    protected String pnames[]  = null;
-    /**
-     * parameter values
-     *
-     * @serial
-     */
-    protected String pvalues[] = null;
-    /**
-     * external form of this mime type
-     *
-     * @serial
-     */
-    protected String external  = null ;
+	/**
+	 * String representation of type
+	 *
+	 * @serial
+	 */
+	protected String type = null;
+	/**
+	 * String representation of subtype
+	 *
+	 * @serial
+	 */
+	protected String subtype = null;
+	/**
+	 * parameter names
+	 *
+	 * @serial
+	 */
+	protected String pnames[] = null;
+	/**
+	 * parameter values
+	 *
+	 * @serial
+	 */
+	protected String pvalues[] = null;
+	/**
+	 * external form of this mime type
+	 *
+	 * @serial
+	 */
+	protected String external = null;
 
-    /**
-     * How good the given MimeType matches the receiver of the method ?
-     *  This method returns a matching level among:
-     * <dl>
-     * <dt>NO_MATCH<dd>Types not matching,</dd>
-     * <dt>MATCH_TYPE<dd>Types match,</dd>
-     * <dt>MATCH_SPECIFIC_TYPE<dd>Types match exactly,</dd>
-     * <dt>MATCH_SUBTYPE<dd>Types match, subtypes matches too</dd>
-     * <dt>MATCH_SPECIFIC_SUBTYPE<dd>Types match, subtypes matches exactly</dd>
-     * </dl>
-     * The matches are ranked from worst match to best match, a simple
-     * Max ( match[i], matched) will give the best match.
-     * @param other The other MimeType to match against ourself.
-     */
+	/**
+	 * How good the given MimeType matches the receiver of the method ?
+	 * This method returns a matching level among:
+	 * <dl>
+	 * <dt>NO_MATCH<dd>Types not matching,</dd>
+	 * <dt>MATCH_TYPE<dd>Types match,</dd>
+	 * <dt>MATCH_SPECIFIC_TYPE<dd>Types match exactly,</dd>
+	 * <dt>MATCH_SUBTYPE<dd>Types match, subtypes matches too</dd>
+	 * <dt>MATCH_SPECIFIC_SUBTYPE<dd>Types match, subtypes matches exactly</dd>
+	 * </dl>
+	 * The matches are ranked from worst match to best match, a simple
+	 * Max ( match[i], matched) will give the best match.
+	 *
+	 * @param other The other MimeType to match against ourself.
+	 */
 
-    public int match (MimeType other) {
-	int match = NO_MATCH;
-	// match types:
-	if ( (type == star) || (other.type == star) ) {
-	    return MATCH_TYPE;
-	} else if ( type != other.type ) {
-	    return NO_MATCH ;
-	} else {
-	    match = MATCH_SPECIFIC_TYPE;
-	}
-	// match subtypes:
-	if ( (subtype == star) || (other.subtype == star) ) {
-	    match = MATCH_SUBTYPE ;
-	} else if ( subtype != other.subtype ) {
-	    return NO_MATCH;
-	} else {
-	    match = MATCH_SPECIFIC_SUBTYPE;
+	public int match(MimeType other) {
+		int match = NO_MATCH;
+		// match types:
+		if ((type == star) || (other.type == star)) {
+			return MATCH_TYPE;
+		} else if (type != other.type) {
+			return NO_MATCH;
+		} else {
+			match = MATCH_SPECIFIC_TYPE;
+		}
+		// match subtypes:
+		if ((subtype == star) || (other.subtype == star)) {
+			match = MATCH_SUBTYPE;
+		} else if (subtype != other.subtype) {
+			return NO_MATCH;
+		} else {
+			match = MATCH_SPECIFIC_SUBTYPE;
+		}
+		return match;
 	}
-	return match;
-    }
 
-    /**
-     * Find out if mime types are equivalent, based on heuristics
-     * like text/xml <=> application/xml and other problems related
-     * to format that may have multiple mime types.
-     * Note that text/html and application/xhtml+xml are not exactly
-     * the same
-     * @param mtype, a MimeType
-     * @return a boolean, true if the two mime types are equivalent
-     */
-    public  boolean equiv(MimeType mtype) {
-	if (match(mtype) == MATCH_SPECIFIC_SUBTYPE) {
-	    return true;
-	}
-	if ((match(TEXT_XML) == MATCH_SPECIFIC_SUBTYPE) ||
-	    (match(APPLICATION_XML)== MATCH_SPECIFIC_SUBTYPE) ) {
-	    if ((mtype.match(TEXT_XML) == MATCH_SPECIFIC_SUBTYPE) ||
-		(mtype.match(APPLICATION_XML) == MATCH_SPECIFIC_SUBTYPE)) {
-		return true;
-	    }
+	/**
+	 * Find out if mime types are equivalent, based on heuristics
+	 * like text/xml <=> application/xml and other problems related
+	 * to format that may have multiple mime types.
+	 * Note that text/html and application/xhtml+xml are not exactly
+	 * the same
+	 *
+	 * @param mtype, a MimeType
+	 * @return a boolean, true if the two mime types are equivalent
+	 */
+	public boolean equiv(MimeType mtype) {
+		if (match(mtype) == MATCH_SPECIFIC_SUBTYPE) {
+			return true;
+		}
+		if ((match(TEXT_XML) == MATCH_SPECIFIC_SUBTYPE) ||
+				(match(APPLICATION_XML) == MATCH_SPECIFIC_SUBTYPE)) {
+			if ((mtype.match(TEXT_XML) == MATCH_SPECIFIC_SUBTYPE) ||
+					(mtype.match(APPLICATION_XML) == MATCH_SPECIFIC_SUBTYPE)) {
+				return true;
+			}
+		}
+		return false;
 	}
-	return false;
-    }
-    /**
-     * A printable representation of this MimeType.
-     * The printed representation is guaranteed to be parseable by the
-     * String constructor.
-     */
 
-    public String toString () {
-	if ( external == null ) {
-	    StringBuilder sb = new StringBuilder(type) ;
-	    sb.append((char) '/') ;
-	    sb.append (subtype) ;
-	    if ( pnames != null ) {
-		for (int i = 0 ; i < pnames.length; i++) {
-		    sb.append(';');
-		    sb.append(pnames[i]);
-		    if ( pvalues[i] != null ) {
-			sb.append('=');
-			sb.append(pvalues[i]);
-		    }
+	/**
+	 * A printable representation of this MimeType.
+	 * The printed representation is guaranteed to be parseable by the
+	 * String constructor.
+	 */
+
+	public String toString() {
+		if (external == null) {
+			StringBuilder sb = new StringBuilder(type);
+			sb.append((char) '/');
+			sb.append(subtype);
+			if (pnames != null) {
+				for (int i = 0; i < pnames.length; i++) {
+					sb.append(';');
+					sb.append(pnames[i]);
+					if (pvalues[i] != null) {
+						sb.append('=');
+						sb.append(pvalues[i]);
+					}
+				}
+			}
+			external = sb.toString().intern();
 		}
-	    }
-	    external = sb.toString().intern();
+		return external;
 	}
-	return external ;
-    }
 
-    /**
-     * Does this MIME type has some value for the given parameter ?
-     * @param name The parameter to check.
-     * @return <strong>True</strong> if this parameter has a value, false
-     *    otherwise.
-     */
-    public boolean hasParameter (String name) {
-	if (name != null) {
-	    if ( pnames != null ) {
-		String lname = name.toLowerCase();
-            for (String pname : pnames) {
-                if (pname.equals(name))
-                    return true;
-            }
-	    }
+	/**
+	 * Does this MIME type has some value for the given parameter ?
+	 *
+	 * @param name The parameter to check.
+	 * @return <strong>True</strong> if this parameter has a value, false
+	 *         otherwise.
+	 */
+	public boolean hasParameter(String name) {
+		if (name != null) {
+			if (pnames != null) {
+				String lname = name.toLowerCase();
+				for (String pname : pnames) {
+					if (pname.equals(name))
+						return true;
+				}
+			}
+		}
+		return false;
 	}
-	return false ;
-    }
 
-    /**
-     * Get the major type of this mime type.
-     * @return The major type, encoded as a String.
-     */
+	/**
+	 * Get the major type of this mime type.
+	 *
+	 * @return The major type, encoded as a String.
+	 */
 
-    public String getType() {
-	return type;
-    }
+	public String getType() {
+		return type;
+	}
 
-    /**
-     * Get the minor type (subtype) of this mime type.
-     * @return The minor or subtype encoded as a String.
-     */
-    public String getSubtype() {
-	return subtype;
-    }
+	/**
+	 * Get the minor type (subtype) of this mime type.
+	 *
+	 * @return The minor or subtype encoded as a String.
+	 */
+	public String getSubtype() {
+		return subtype;
+	}
 
-    /**
-     * Get a mime type parameter value.
-     * @param name The parameter whose value is to be returned.
-     * @return The parameter value, or <b>null</b> if not found.
-     */
-    public String getParameterValue (String name) {
-	if (name != null) {
-	    if ( pnames != null ) {
-	    String lname = name.toLowerCase();
-		for (int i = 0 ; i < pnames.length ; i++) {
-		    if ( pnames[i].equals(lname) )
-			return pvalues[i];
+	/**
+	 * Get a mime type parameter value.
+	 *
+	 * @param name The parameter whose value is to be returned.
+	 * @return The parameter value, or <b>null</b> if not found.
+	 */
+	public String getParameterValue(String name) {
+		if (name != null) {
+			if (pnames != null) {
+				String lname = name.toLowerCase();
+				for (int i = 0; i < pnames.length; i++) {
+					if (pnames[i].equals(lname))
+						return pvalues[i];
+				}
+			}
 		}
-	    }
+		return null;
 	}
-	return null ;
-    }
 
-    /**
-     * adds some parameters to a MimeType
-     * @param param a String array of parameter names
-     * @param values the corresponding String array of values
-     */
-    public void addParameters(String[] param, String[] values) {
-	// sanity check
-	if ((param == null) || (values == null) ||
-	    (values.length != param.length))
-	    return;
-	if (pnames == null) {
-	    pnames = param;
-	    pvalues = values;
-	} else {
-	    String[] nparam = new String[pnames.length+param.length];
-	    String[] nvalues = new String[pvalues.length+values.length];
-	    System.arraycopy(pnames, 0, nparam, 0, pnames.length);
-	    System.arraycopy(param, 0, nparam, pnames.length, param.length);
-	    System.arraycopy(pvalues, 0, nvalues, 0, pvalues.length);
-	    System.arraycopy(values,0, nvalues, pvalues.length, values.length);
-	    pnames = nparam;
-	    pvalues = nvalues;
-	}
-	for (int i = 0; i < pnames.length; i++) {
-	    pnames[i] = pnames[i].toLowerCase();
+	/**
+	 * adds some parameters to a MimeType
+	 *
+	 * @param param  a String array of parameter names
+	 * @param values the corresponding String array of values
+	 */
+	public void addParameters(String[] param, String[] values) {
+		// sanity check
+		if ((param == null) || (values == null) ||
+				(values.length != param.length))
+			return;
+		if (pnames == null) {
+			pnames = param;
+			pvalues = values;
+		} else {
+			String[] nparam = new String[pnames.length + param.length];
+			String[] nvalues = new String[pvalues.length + values.length];
+			System.arraycopy(pnames, 0, nparam, 0, pnames.length);
+			System.arraycopy(param, 0, nparam, pnames.length, param.length);
+			System.arraycopy(pvalues, 0, nvalues, 0, pvalues.length);
+			System.arraycopy(values, 0, nvalues, pvalues.length, values.length);
+			pnames = nparam;
+			pvalues = nvalues;
+		}
+		for (int i = 0; i < pnames.length; i++) {
+			pnames[i] = pnames[i].toLowerCase();
+		}
+		external = null;
 	}
-	external = null;
-    }
 
-    /**
-     * get a clone of this object
-     * @return another cloned instance of MimeType
-     */
-    public MimeType getClone() {
-	try {
-	    return (MimeType) clone();
-	} catch (CloneNotSupportedException ex) {
-	    // should never happen as we are Cloneable!
+	/**
+	 * get a clone of this object
+	 *
+	 * @return another cloned instance of MimeType
+	 */
+	public MimeType getClone() {
+		try {
+			return (MimeType) clone();
+		} catch (CloneNotSupportedException ex) {
+			// should never happen as we are Cloneable!
+		}
+		// never reached
+		return null;
 	}
-	// never reached
-	return null;
-    }
 
-    /**
-     * adds a parameterto a MimeType
-     * @param param the parameter name, as a String
-     * @param value  the parameter value, as a Sting
-     */
-    public void addParameter(String param, String value) {
-	String[] p = new String[1];
-	String[] v = new String[1];
-	p[0] = param;
-	v[0] = value;
-	addParameters(p, v);
-    }
+	/**
+	 * adds a parameterto a MimeType
+	 *
+	 * @param param the parameter name, as a String
+	 * @param value the parameter value, as a Sting
+	 */
+	public void addParameter(String param, String value) {
+		String[] p = new String[1];
+		String[] v = new String[1];
+		p[0] = param;
+		v[0] = value;
+		addParameters(p, v);
+	}
 
-    /**
-     * Set the parameter to a MimeType (replace old value if any).
-     * @param param the parameter name, as a String
-     * @param value  the parameter value, as a Sting
-     */
-    public void setParameter(String param, String value) {
-	if (pnames == null) {
-	    addParameter(param, value);
-	} else {
-	    String lparam = param.toLowerCase();
-	    for (int i = 0 ; i < pnames.length ; i++) {
-		if (pnames[i].equals(lparam)) {
-		    pvalues[i] = value;
-		    return;
+	/**
+	 * Set the parameter to a MimeType (replace old value if any).
+	 *
+	 * @param param the parameter name, as a String
+	 * @param value the parameter value, as a Sting
+	 */
+	public void setParameter(String param, String value) {
+		if (pnames == null) {
+			addParameter(param, value);
+		} else {
+			String lparam = param.toLowerCase();
+			for (int i = 0; i < pnames.length; i++) {
+				if (pnames[i].equals(lparam)) {
+					pvalues[i] = value;
+					return;
+				}
+			}
+			addParameter(lparam, value);
 		}
-	    }
-	    addParameter(lparam, value);
 	}
-    }
 
-    /**
-     * Construct  MimeType object for the given string.
-     * The string should be the representation of the type. This methods
-     * tries to be compliant with HTTP1.1, p 15, although it is not
-     * (because of quoted-text not being accepted).
-     * FIXME
-     * @parameter spec A string representing a MimeType
-     * @return A MimeType object
-     * @exception MimeTypeFormatException if the string couldn't be parsed.
-     */
-    public MimeType (String spec)
-	throws MimeTypeFormatException
-    {
-	int strl  = spec.length() ;
-	int start = 0, look = -1 ;
-	// skip leading/trailing blanks:
-	while ((start < strl) && (spec.charAt (start)) <= ' ')
-	    start++ ;
-	while ((strl > start) && (spec.charAt (strl-1) <= ' '))
-	    strl-- ;
-	// get the type:
-	StringBuilder sb = new StringBuilder() ;
-	while ((start < strl) && ((look = spec.charAt(start)) != '/')) {
-	    sb.append (Character.toLowerCase((char) look)) ;
-	    start++ ;
-	}
-	if ( look != '/' )
-	    throw new MimeTypeFormatException (spec) ;
-	this.type = sb.toString().intern() ;
-	// get the subtype:
-	start++ ;
-	sb.setLength(0) ;
-	while ((start < strl)
-	       && ((look = spec.charAt(start)) > ' ') && (look != ';')) {
-	    sb.append (Character.toLowerCase((char) look)) ;
-	    start++ ;
-	}
-	this.subtype = sb.toString().intern() ;
-	// get parameters, if any:
-	while ((start < strl) && ((look = spec.charAt(start)) <= ' '))
-	    start++ ;
-	if ( start < strl ) {
-	    if (spec.charAt(start) != ';')
-		throw new MimeTypeFormatException (spec) ;
-	    start++ ;
-	    ArrayList vp = new ArrayList(4) ;
-	    ArrayList vv = new ArrayList(4) ;
-	    while ( start < strl ) {
-		while ((start < strl) && (spec.charAt(start) <= ' ')) start++ ;
-		// get parameter name:
-		sb.setLength (0) ;
-		while ((start < strl)
-		       && ((look=spec.charAt(start)) > ' ') && (look != '=')) {
-		    sb.append (Character.toLowerCase((char) look)) ;
-		    start++ ;
+	/**
+	 * Construct  MimeType object for the given string.
+	 * The string should be the representation of the type. This methods
+	 * tries to be compliant with HTTP1.1, p 15, although it is not
+	 * (because of quoted-text not being accepted).
+	 * FIXME
+	 *
+	 * @return A MimeType object
+	 * @throws MimeTypeFormatException if the string couldn't be parsed.
+	 * @parameter spec A string representing a MimeType
+	 */
+	public MimeType(String spec)
+			throws MimeTypeFormatException {
+		int strl = spec.length();
+		int start = 0, look = -1;
+		// skip leading/trailing blanks:
+		while ((start < strl) && (spec.charAt(start)) <= ' ')
+			start++;
+		while ((strl > start) && (spec.charAt(strl - 1) <= ' '))
+			strl--;
+		// get the type:
+		StringBuilder sb = new StringBuilder();
+		while ((start < strl) && ((look = spec.charAt(start)) != '/')) {
+			sb.append(Character.toLowerCase((char) look));
+			start++;
 		}
-		String name = sb.toString() ;
-		// get the value:
-		while ((start < strl) && (spec.charAt(start) <= ' ')) start++ ;
-		if (spec.charAt(start) != '=')
-		    throw new MimeTypeFormatException (spec) ;
-		start++ ;
-		while ((start < strl) &&
-		       ((spec.charAt(start) == '"') ||
-			(spec.charAt(start) <= ' '))) start++ ;
-		sb.setLength(0) ;
+		if (look != '/')
+			throw new MimeTypeFormatException(spec);
+		this.type = sb.toString().intern();
+		// get the subtype:
+		start++;
+		sb.setLength(0);
 		while ((start < strl)
-		       && ((look=spec.charAt(start)) > ' ')
-		       && (look != ';')
-		       && (look != '"')) {
-		    sb.append ((char) look) ;
-		    start++ ;
+				&& ((look = spec.charAt(start)) > ' ') && (look != ';')) {
+			sb.append(Character.toLowerCase((char) look));
+			start++;
+		}
+		this.subtype = sb.toString().intern();
+		// get parameters, if any:
+		while ((start < strl) && ((look = spec.charAt(start)) <= ' '))
+			start++;
+		if (start < strl) {
+			if (spec.charAt(start) != ';')
+				throw new MimeTypeFormatException(spec);
+			start++;
+			ArrayList<String> vp = new ArrayList<String>(4);
+			ArrayList<String> vv = new ArrayList<String>(4);
+			while (start < strl) {
+				while ((start < strl) && (spec.charAt(start) <= ' ')) start++;
+				// get parameter name:
+				sb.setLength(0);
+				while ((start < strl)
+						&& ((look = spec.charAt(start)) > ' ') && (look != '=')) {
+					sb.append(Character.toLowerCase((char) look));
+					start++;
+				}
+				String name = sb.toString();
+				// get the value:
+				while ((start < strl) && (spec.charAt(start) <= ' ')) start++;
+				if (spec.charAt(start) != '=')
+					throw new MimeTypeFormatException(spec);
+				start++;
+				while ((start < strl) &&
+						((spec.charAt(start) == '"') ||
+								(spec.charAt(start) <= ' '))) start++;
+				sb.setLength(0);
+				while ((start < strl)
+						&& ((look = spec.charAt(start)) > ' ')
+						&& (look != ';')
+						&& (look != '"')) {
+					sb.append((char) look);
+					start++;
+				}
+				while ((start < strl) && (spec.charAt(start) != ';')) start++;
+				start++;
+				String value = sb.toString();
+				vp.add(name);
+				vv.add(value);
+			}
+			this.pnames = vp.toArray(new String[vp.size()]);
+			this.pvalues = vv.toArray(new String[vv.size()]);
 		}
-		while ((start < strl) && (spec.charAt(start) != ';')) start++ ;
-		start++ ;
-		String value = sb.toString() ;
-		vp.add(name);
-		vv.add(value);
-	    }
-	    this.pnames = new String[vp.size()];
-	    vp.toArray(pnames);
-	    this.pvalues = new String[vv.size()];
-	    vv.toArray(pvalues);
 	}
-    }
 
-    public MimeType (String type, String subtype
-		     , String pnames[], String pvalues[]) {
-	this.type    = type.toLowerCase().intern() ;
-	this.subtype = subtype.toLowerCase().intern() ;
-	this.pnames  = pnames;
-	this.pvalues = pvalues;
-    }
+	public MimeType(String type, String subtype
+			, String pnames[], String pvalues[]) {
+		this.type = type.toLowerCase().intern();
+		this.subtype = subtype.toLowerCase().intern();
+		this.pnames = pnames;
+		this.pvalues = pvalues;
+	}
 
-    public MimeType (String type, String subtype) {
-	this.type    = type.toLowerCase().intern();
-	this.subtype = subtype.toLowerCase().intern();
-    }
+	public MimeType(String type, String subtype) {
+		this.type = type.toLowerCase().intern();
+		this.subtype = subtype.toLowerCase().intern();
+	}
 
-    public static void main (String args[]) {
-	if ( args.length == 1) {
-	    MimeType type = null ;
-	    try {
-		type = new MimeType (args[0]) ;
-	    } catch (MimeTypeFormatException e) {
-	    }
-	    if ( type != null ) {
-		System.out.println (type) ;
-		if (type.getClone().match(type) == MATCH_SPECIFIC_SUBTYPE) {
-		    System.out.println("Clone OK");
+	public static void main(String args[]) {
+		if (args.length == 1) {
+			MimeType type = null;
+			try {
+				type = new MimeType(args[0]);
+			} catch (MimeTypeFormatException e) {
+			}
+			if (type != null) {
+				System.out.println(type);
+				if (type.getClone().match(type) == MATCH_SPECIFIC_SUBTYPE) {
+					System.out.println("Clone OK");
+				} else {
+					System.out.println("Cloning failed");
+				}
+			} else {
+				System.out.println("Invalid mime type specification.");
+			}
 		} else {
-		    System.out.println("Cloning failed");
+			System.out.println("Usage: java MimeType <type-to-parse>");
 		}
-	    } else {
-		System.out.println ("Invalid mime type specification.") ;
-	    }
-	} else {
-	    System.out.println ("Usage: java MimeType <type-to-parse>") ;
 	}
-    }
 
 }
Received on Saturday, 4 August 2012 21:17:12 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 7 January 2015 15:17:50 UTC