for (index++; index < length; index++) {		    c = s.charAt(index);		    switch (c) {		    case '\\':			index++; // skip both '\' and the escaped char			break;		    case '"':			break outq; // out of for loop		    default:			break;		    }		}		if (index >= length)		    throw new AddressException("Missing '\"'", s, index);		break;	    case '[':	// a domain-literal, probably		rfc822 = true;	      outb:		for (index++; index < length; index++) {		    c = s.charAt(index);		    switch (c) {		    case '\\':			index++; // skip both '\' and the escaped char			break;		    case ']':			break outb; // out of for loop		    default:			break;		    }		}		if (index >= length)		    throw new AddressException("Missing ']'", s, index);		break;	    case ',':	// end of an address, probably		if (start == -1) {		    route_addr = false;		    rfc822 = false;		    start = end = -1;		    break;	// nope, nothing there		}		if (in_group) {		    route_addr = false;		    break;		}		// got a token, add this to our InternetAddress vector		if (end == -1)		    end = index;		String addr = s.substring(start, end).trim();		if (rfc822 || strict || parseHdr) {		    if (strict || !parseHdr)			checkAddress(addr, route_addr, false);		    ma = new InternetAddress();		    ma.setAddress(addr);		    if (start_personal >= 0) {			ma.encodedPersonal = unquote(			    s.substring(start_personal, end_personal).trim());			start_personal = end_personal = -1;		    }		    v.addElement(ma);		} else {		    // maybe we passed over more than one space-separated addr		    StringTokenizer st = new StringTokenizer(addr);		    while (st.hasMoreTokens()) {			String a = st.nextToken();			checkAddress(a, false, false);			ma = new InternetAddress();			ma.setAddress(a);			v.addElement(ma);		    }		}		route_addr = false;		rfc822 = false;		start = end = -1;		break;	    case ':':		rfc822 = true;		if (in_group)		    throw new AddressException("Nested group", s, index);		in_group = true;		if (start == -1)		    start = index;		break;	    case ';':		if (start == -1)		    start = index;		if (!in_group)		    throw new AddressException(			    "Illegal semicolon, not in group", s, index);		in_group = false;		if (start == -1)		    start = index;		ma = new InternetAddress();		end = index + 1;		ma.setAddress(s.substring(start, end).trim());		v.addElement(ma);		route_addr = false;		start = end = -1;		break;	    // Ignore whitespace	    case ' ':	    case '\t':	    case '\r':	    case '\n':		break;	    default:		if (start == -1)		    start = index;		break;	     }	}	if (start >= 0) {	    /*	     * The last token, add this to our InternetAddress vector.	     * Note that this block of code should be identical to the	     * block above for "case ','".	     */	    if (end == -1)		end = index;	    String addr = s.substring(start, end).trim();	    if (rfc822 || strict || parseHdr) {		if (strict || !parseHdr)		    checkAddress(addr, route_addr, false);		ma = new InternetAddress();		ma.setAddress(addr);		if (start_personal >= 0) {		    ma.encodedPersonal = unquote(			    s.substring(start_personal, end_personal).trim());		}		v.addElement(ma);	    } else {		// maybe we passed over more than one space-separated addr		StringTokenizer st = new StringTokenizer(addr);		while (st.hasMoreTokens()) {		    String a = st.nextToken();		    checkAddress(a, false, false);		    ma = new InternetAddress();		    ma.setAddress(a);		    v.addElement(ma);		}	    }	}	InternetAddress[] a = new InternetAddress[v.size()];	v.copyInto(a);	return a;    }    /**     * Validate that this address conforms to the syntax rules of     * RFC 822.  The current implementation checks many, but not     * all, syntax rules.  Note that even though the syntax of     * the address may be correct, there's no guarantee that a     * mailbox of that name exists.     *     * @exception	AddressException if the address isn't valid.     * @since		JavaMail 1.3     */    public void validate() throws AddressException {	checkAddress(getAddress(), true, true);    }    private static final String specialsNoDotNoAt = "()<>,;:\\\"[]";    private static final String specialsNoDot = specialsNoDotNoAt + "@";    /**     * Check that the address is a valid "mailbox" per RFC822.     * (We also allow simple names.)     *     * XXX - much more to check     * XXX - doesn't handle domain-literals properly (but no one uses them)     */    private static void checkAddress(String addr,				boolean routeAddr, boolean validate)				throws AddressException {	int i, start = 0;	if (addr.indexOf('"') >= 0)	    return;			// quote in address, too hard to check	if (routeAddr) {	    /*	     * Check for a legal "route-addr":	     *		[@domain[,@domain ...]:]local@domain	     */	    for (start = 0; (i = indexOfAny(addr, ",:", start)) >= 0;		    start = i+1) {		if (addr.charAt(start) != '@')		    throw new AddressException("Illegal route-addr", addr);		if (addr.charAt(i) == ':') {		    // end of route-addr		    start = i + 1;		    break;		}	    }	}	/*	 * The rest should be "local@domain", but we allow simply "local"	 * unless called from validate.	 */	String local;	String domain;	if ((i = addr.indexOf('@', start)) >= 0) {	    if (i == start)		throw new AddressException("Missing local name", addr);	    if (i == addr.length() - 1)		throw new AddressException("Missing domain", addr);	    local = addr.substring(start, i);	    domain = addr.substring(i + 1);	} else {	    /*	     * Note that the MimeMessage class doesn't remember addresses	     * as separate objects; it writes them out as headers and then	     * parses the headers when the addresses are requested.	     * In order to support the case where a "simple" address is used,	     * but the address also has a personal name and thus looks like	     * it should be a valid RFC822 address when parsed, we only check	     * this if we're explicitly called from the validate method.	     */	    if (validate)		throw new AddressException("Missing final '@domain'", addr);	    /*	     * No '@' so it's not *really* an RFC822 address, but still	     * we allow some simple forms.	     */	    local = addr;	    domain = null;	}	// there better not be any whitespace in it	if (indexOfAny(addr, " \t\n\r") >= 0)	    throw new AddressException("Illegal whitespace in address", addr);	// local-part must follow RFC822, no specials except '.'	if (indexOfAny(local, specialsNoDot) >= 0)	    throw new AddressException("Illegal character in local name", addr);	// check for illegal chars in the domain, but ignore domain literals	if (domain != null && domain.indexOf('[') < 0) {	    if (indexOfAny(domain, specialsNoDot) >= 0)		throw new AddressException("Illegal character in domain", addr);	}    }    /**     * Is this a "simple" address?  Simple addresses don't contain quotes     * or any RFC822 special characters other than '@' and '.'.     */    private boolean isSimple() {	return address == null || indexOfAny(address, specialsNoDotNoAt) < 0;    }    /**     * Indicates whether this address is an RFC 822 group address.     * Note that a group address is different than the mailing     * list addresses supported by most mail servers.  Group addresses     * are rarely used; see RFC 822 for details.     *     * @return		true if this address represents a group     * @since		JavaMail 1.3     */    public boolean isGroup() {	// quick and dirty check	return address != null &&	    address.endsWith(";") && address.indexOf(':') > 0;    }    /**     * Return the members of a group address.  A group may have zero,     * one, or more members.  If this address is not a group, null     * is returned.  The <code>strict</code> parameter controls whether     * the group list is parsed using strict RFC 822 rules or not.     * The parsing is done using the <code>parseHeader</code> method.     *     * @return		array of InternetAddress objects, or null     * @exception	AddressException if the group list can't be parsed     * @since		JavaMail 1.3     */    public InternetAddress[] getGroup(boolean strict) throws AddressException {	Vector groups = null;	String addr = getAddress();	// groups are of the form "name:addr,addr,...;"	if (!addr.endsWith(";"))	    return null;	int ix = addr.indexOf(':');	if (ix < 0)	    return null;	// extract the list	String list = addr.substring(ix + 1, addr.length() - 1);	// parse it and return the individual addresses	return InternetAddress.parseHeader(list, strict);    }    /**     * Return the first index of any of the characters in "any" in "s",     * or -1 if none are found.     *     * This should be a method on String.     */    private static int indexOfAny(String s, String any) {	return indexOfAny(s, any, 0);    }    private static int indexOfAny(String s, String any, int start) {	try {	    int len = s.length();	    for (int i = start; i < len; i++) {		if (any.indexOf(s.charAt(i)) >= 0)		    return i;	    }	    return -1;	} catch (StringIndexOutOfBoundsException e) {	    return -1;	}    }    /*    public static void main(String argv[]) throws Exception {	for (int i = 0; i < argv.length; i++) {	    InternetAddress[] a = InternetAddress.parse(argv[i]);	    for (int j = 0; j < a.length; j++) {		System.out.println("arg " + i + " address " + j + ": " + a[j]);		System.out.println("\tAddress: " + a[j].getAddress() +				    "\tPersonal: " + a[j].getPersonal());	    }	    if (a.length > 1) {		System.out.println("address 0 hash code: " + a[0].hashCode());		System.out.println("address 1 hash code: " + a[1].hashCode());		if (a[0].hashCode() == a[1].hashCode())		    System.out.println("success, hashcodes equal");		else		    System.out.println("fail, hashcodes not equal");		if (a[0].equals(a[1]))		    System.out.println("success, addresses equal");		else		    System.out.println("fail, addresses not equal");		if (a[1].equals(a[0]))		    System.out.println("success, addresses equal");		else		    System.out.println("fail, addresses not equal");	    }	}    }    */}