function checkForNull(theForm)
{
   var flag = true;
   if(theForm == "")
   {
      flag=false;
   }
   return flag;
}

function checkNum(value)
{
   var flag=true;
   if(isNaN(value))
   {
      
      flag=false;
   }
       
   return flag;
}



function emailCheck (emailStr)
{
   
   var emailPat=/^(.+)@(.+)$/;
   var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]";


   /* The following string represents the range of characters allowed in a 
      username or domainname.  It really states which chars aren't allowed. */

   var validChars="\[^\\s" + specialChars + "\]";


   /* The following pattern applies if the "user" is a quoted string (in
      which case, there are no rules about which characters are allowed
      and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com
      is a legal e-mail address. */

   var quotedUser="(\"[^\"]*\")";


   /* The following pattern 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})\]$/;


   /* The following string represents an atom (basically a series of
      non-special characters.) */

   var atom=validChars + '+';


   /* The following string represents one word in the typical username.
      For example, in john.doe@somewhere.com, john and doe are words.
      Basically, a word is either an atom or quoted string. */

   var word="(" + atom + "|" + quotedUser + ")";


   // The following pattern describes the structure of the user

   var userPat=new RegExp("^" + word + "(\\." + word + ")*$");


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



   /* Begin with the coarse pattern to simply break up user@domain into
      different pieces that are easy to analyze. */


   var matchArray=emailStr.match(emailPat);
   if (matchArray==null) {
     /* Too many/few @'s or something; basically, this address doesn't
        even fit the general mould of a valid e-mail address. */

      alert("Email address seems incorrect (check @ and .'s)");
      return false;
   }
   var user=matchArray[1];
   var domain=matchArray[2];

   // See if "user" is valid 
   if (user.match(userPat)==null) 
   {
       // user is not valid
       alert("The username doesn't seem to be valid.");
       return false;
   }

   /* 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) 
         {
            alert("Destination IP address is invalid!");
            return false;
         }
      }
      return true;
   }

   // Domain is symbolic name
   var domainArray=domain.match(domainPat);

   if (domainArray==null) 
   {
      alert("The domain name doesn't seem to be valid.");
      return false;
   }

   /* domain name seems valid, but now make sure that it ends in a
      three-letter word (like com, edu, gov) or a two-letter word,
      representing country (uk, nl), and that there's a hostname preceding 
      the domain or country. */

   /* Now we need to break up the domain to get a count of how many atoms
      it consists of. */

   var atomPat=new RegExp(atom,"g");
   var domArr=domain.match(atomPat);
   var len=domArr.length;
   if (domArr[domArr.length-1].length<2 || domArr[domArr.length-1].length>3) 
   {
      // the address must end in a two letter or three letter word.
      alert("The address must end in a three-letter domain, or two letter country.");
      return false;
   }

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


   return true;
}


// Validate Phone number or Fax number
function phoneFax( number )
{
   for ( var i = 0; i < number.length; i++ )
   {
      var c = number.charAt( i );

      if ( ( ( c  < '0' ) || ( c  > '9' ) )
          && ( c != ' ' ) && ( c != '+' ) && ( c != '(' ) && ( c != ')' )
          && ( c != '[' ) && ( c != ']' ) && ( c != '-' ) && ( c != '.' )
         )
      {
         return false;
      }
   }

   return true;
}


// Validate IP address or Ariel address
function verifyIP (IPvalue) 
{
   errorString = "";
   theName = "IPaddress";
   
   var ipPattern = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
   var ipArray = IPvalue.match(ipPattern); 
   
   if (IPvalue == "0.0.0.0")
   errorString = errorString + theName + ': '+IPvalue+' is a special IP address and cannot be used here.';
   else if (IPvalue == "255.255.255.255")
   errorString = errorString + theName + ': '+IPvalue+' is a special IP address and cannot be used here.';
   if (ipArray == null)
   errorString = errorString + theName + ': '+IPvalue+' is not a valid IP address.';
   else 
   {
      for (i = 0; i < 4; i++) 
      {
         thisSegment = ipArray[i];
         if (thisSegment > 255) 
         {
            errorString = errorString + theName + ': '+IPvalue+' is not a valid IP address.';
            i = 4;
         }
         if ((i == 0) && (thisSegment > 255)) 
         {
            errorString = errorString + theName + ': '+IPvalue+' is a special IP address and cannot be used here.';
            i = 4;
         }
      }
   }
   extensionLength = 3;
   if (errorString == "")
   return true;
   else
   return false;
   
 }



// Validate Ariel address
// must support the following formats:
// xxx.xxx.xxx.xxx - standard IP address
// xxx.xxx.xxx.xxx/xxx.xxx.xxx.xxx - stacked/firewalled IP address
function verifyAriel (arielValue)
{
   errorString = "";

   // first determine whether it is a normal Ariel address
   if ( verifyIP( arielValue ) )
   {
        return true;
   }


   // split string into 2 separate IP addresses
   // locate dividing "/"
   divideLocation = arielValue.indexOf( '/' );

   // if we failed to locate / then it must be an invalid Ariel address
   if( divideLocation == -1 )
   {
        return false;
   }
   else
   {
     forwardIP = arielValue.substring( 0, divideLocation );
     destinationIP  = arielValue.substring( divideLocation+1, arielValue.length );

     return( verifyIP(forwardIP) && verifyIP(destinationIP) );
   }
 }