function verifyEmailAddress(emailStr)
  {
   // Custom-built function that checks for a valid e-mail address format. If the e-mail 
   // address is invalid, the function returns an error message. Otherwise, the function
   // returns null.

   // The following variable tells the rest of the function whether or not
   // to verify that the address ends in a two-letter country or well-known
   // TLD. True (1) means check it, false (0) means don't.
   var checkTLD = true;

   // List of known TLDs that an e-mail address must end with.
   var knownDomsPat = /^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;

   // Pattern used to check if the entered e-mail address fits the user@domain format. It
   // also is used to separate the username from the domain.
   var emailPat = /^(.+)@(.+)$/;

   // String that represents the pattern for matching all special characters (special characters 
   // are not allowed in the address). These characters include ( ) < > @ , ; : \ " . [ ].
   var specialChars = "\\(\\)><@,;:\\\\\\\"\\.\\[\\]";

   // String that represents the range of characters allowed in a username or domainname. It
   // really states which chars are not allowed.
   var validChars = "\[^\\s" + specialChars + "\]";

   // Pattern that applies if the "user" is a quoted string (in that case, there are no rules
   // about which characters are allowed and which are not). E.g. "jiminy cricket"@disney.com
   // is a legal e-mail address.
   var quotedUser = "(\"[^\"]*\")";

   // Pattern that applies for domains that are IP addresses, rather than symbolic names.
   // E.g. joe@[123.124.233.4] is a legal e-mail address. NOTE: The square brackets are
   // required.
   var ipDomainPat = /^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;

   // String that represents an atom (basically a series of non-special characters).
   var atom = validChars + '+';

   // String that represents one word in the typical username. For example, in 
   // john.doe@somewhere.com, both john and doe are words. Basically, a word is
   // either an atom or quoted string.
   var word = "(" + atom + "|" + quotedUser + ")";

   // Pattern that describes the structure of the user.
   var userPat = new RegExp("^" + word + "(\\." + word + ")*$");

   // Pattern that describes the structure of a normal symbolic domain, as opposed to
   // the ipDomainPat variable, shown above.
   var domainPat = new RegExp("^" + atom + "(\\." + atom +")*$");

   // Finally, let's start trying to figure out if the supplied address is valid. Begin with
   // the coarse pattern to simply break up user@domain into different pieces which are easy
   // to analyze.
   var matchArray = emailStr.match(emailPat);

   if(matchArray==null)
     {
      // Too many or to few @'s or something; basically, this address doesn't
      // even fit the general mould of a valid e-mail address.
      return "E-mail address seems incorrect (check @ and .'s).";
     }

   var user   = matchArray[1];
   var domain = matchArray[2];

   // Checking only basic ASCII characters are in the strings (0 - 127).
   for(i = 0; i < user.length; i++)
      {
       if(user.charCodeAt(i) > 127)
         {
          return "E-mail address contains invalid characters.";
         }
      }

   for(i = 0; i < domain.length; i++)
      {
       if(domain.charCodeAt(i) > 127)
         {
          return "Domain name contains invalid characters.";
         }
      }

   // Determine if "user" is valid.
   if(user.match(userPat) == null)
     {
      return "The e-mail address does not seem to be valid.";
     }

   // If the e-mail address is at an IP address (as opposed to a symbolic host name) make
   // sure the IP address is valid.
   var IPArray = domain.match(ipDomainPat);

   if(IPArray != null)
     {
      // This is an IP address.
      for(var i = 1; i <= 4; i++)
         {
          if(IPArray[i] > 255)
            {
             return "Destination IP address is invalid!";
            }
         }
      return null;
     }

   // Domain is symbolic name. Check if it's valid. 
   var atomPat = new RegExp("^" + atom + "$");
   var domArr  = domain.split(".");
   var len     = domArr.length;

   for(i = 0; i< len; i++)
      {
       if(domArr[i].search(atomPat) == -1)
         {
          return "The domain name does not seem to be valid.";
         }
      }

   // Domain name seems valid, but now make sure that it ends in a known top-level domain
   // (like com, edu, gov) or a two-letter word, representing a country (us, uk), and that
   // there is a hostname preceding the domain or country.
   if(checkTLD && domArr[domArr.length-1].length   != 2 && 
      domArr[domArr.length-1].search(knownDomsPat) == -1)
     {
      return "The address must end in a well-known domain or two letter country.";
     }

   // Make sure there's a host name preceding the domain.
   if(len < 2)
     {
      return "This address is missing a hostname!";
     }

   // If we've gotten this far, everything's valid!
   return null;
  }