//------------------------------------------------------------------------------ 
/*
	InputValidation.js
	Release information refers to release.html
	Usage document refers to Usage.html
	Examples refers to Example1-6.html
*/
//------------------------------------------------------------------------------     

/* 
    This is the source code for the general validation functions. 
    Add the following code just after the </HEAD> in the files where the 
    generalised validation functionality is required. 
    <SCRIPT language="JavaScript1.2" src="InputValidation.js"></SCRIPT> 
*/ 

/*  function validateLandline 
*  checks the validity of a mobile number entered 
*   returns true or false 
*/ 
function validateLandline(landlineNum)
{
	var strNum = new String(landlineNum);
	strNum = replaceAll(strNum, " ", "");
	var charpos = strNum.indexOf(")");
	var areacode;
	if (charpos>=0){ // with area code
		areacode = strNum.substr(1,charpos-1);
		if (areacode.length<1 || areacode.length>2 || isNaN(areacode))
			return false;
		if (eval(areacode)>9 || eval(areacode)<2)
			return false;
		strNum = strNum.substr(charpos+1);
	}
	if (strNum.length != 8)
		return false;
	charpos = strNum.search("[^0-9]"); 
	if (charpos >= 0) 
		return false;
	return true;
}

/*  function validateMobile 
*  checks the validity of a landline number entered 
*   returns true or false 
*/ 
function validateMobile(mobileNum)
{
	var strNum = new String(mobileNum);
	strNum = replaceAll(strNum, " ", "");
	if (strNum.length != 10)
		return false;
	var charpos = strNum.search("[^0-9]"); 
	if (charpos >= 0) 
		return false; 
	if (strNum.substring(0,2)!="04" 
		&& strNum.substring(0,2)!="14")
		return false;
	return true;
}
    
/*  function validateEmail 
*  checks the validity of an email address entered 
*   returns true or false 
*/ 
function validateEmail(email)
{
	// a very simple email validation checking. 
	// you can add more complex email checking if it helps 
    var splitted = email.match("^(.+)@(.+)$");
    if(splitted == null) return false;
    if(splitted[1] != null )
    {
		var regexp_user=/^\"?[\w-_\.]*\"?$/;
		if(splitted[1].match(regexp_user) == null) return false;
    }
    if(splitted[2] != null)
    {
		var regexp_domain=/^[\w-\.]*\.[A-Za-z]{2,4}$/;
		if(splitted[2].match(regexp_domain) == null) 
		{
			var regexp_ip =/^\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\]$/;
			if(splitted[2].match(regexp_ip) == null) return false;
		}// if
		return true;
    }
	return false;
}

/*	function getFirstPart
*	return the prefix of a string before specified substr
*	e.g.  getFirstPart("123.456", ".") return "123"
*	e.g.  getFirstPart("123", ".") return "123"
*/
function getFirstPart(strSrc, strSubStr)
{
	var nPos = strSrc.indexOf(strSubStr);
	if (nPos >= 0){
		return strSrc.substring(0,nPos); 
	}
	else{
		return strSrc;
	}
}

/*	function getNextPart
*	return the subfix of a string after specified substr
*	e.g.  getNextPart("123.456", ".") return "456"
*	e.g.  getNextPart("123", ".") return ""
*/
function getNextPart(strSrc, strSubStr)
{
	var nPos = strSrc.indexOf(strSubStr);
	if (nPos >= 0){
		return strSrc.substr(nPos+1);
	}
	else{
		return "";
	}
}

/* function validateData 
*  Checks each field in a form 
*  Called from validateForm function 
*/ 
function validateData(strValidateStr,objValue,strError) 
{ 
    var epos = strValidateStr.search("="); 
    var  command  = ""; 
    var  cmdvalue = ""; 
    if(epos >= 0) 
    { 
     command  = strValidateStr.substring(0,epos); 
     cmdvalue = strValidateStr.substr(epos+1); 
    } 
    else 
    { 
     command = strValidateStr; 
    } 
    
    objValue.value = Trim(objValue.value);

    switch(command) 
    { 
        case "req": 
        case "required": 
         { 
           if(eval(objValue.value.length) == 0) 
           { 
              if(!strError || strError.length ==0) 
              { 
                strError = objValue.name + " : Required Field"; 
              }//if 
              alert(strError); 
              return false; 
           }//if 
           break;             
         }//case required 
        case "maxlength": 
        case "maxlen": 
          { 
             if(eval(objValue.value.length) >  eval(cmdvalue)) 
             { 
               if(!strError || strError.length ==0) 
               { 
                 strError = objValue.name + " : "+cmdvalue+" characters maximum "; 
               }//if 
               alert(strError + "\n[Current length = " + objValue.value.length + " ]"); 
               return false; 
             }//if 
             break; 
          }//case maxlen 
        case "minlength": 
        case "minlen": 
           { 
             if(eval(objValue.value.length) <  eval(cmdvalue)) 
             { 
               if(!strError || strError.length ==0) 
               { 
                 strError = objValue.name + " : " + cmdvalue + " characters minimum  "; 
               }//if               
               alert(strError + "\n[Current length = " + objValue.value.length + " ]"); 
               return false;                 
             }//if 
             break; 
            }//case minlen 
        case "alnum": 
        case "alphanumeric": 
           { 
              var charpos = objValue.value.search("[^A-Za-z0-9]"); 
              if(objValue.value.length > 0 &&  charpos >= 0) 
              { 
               if(!strError || strError.length ==0) 
                { 
                  strError = objValue.name+": Only alpha-numeric characters allowed "; 
                }//if 
                alert(strError + "\n [Error character position " + eval(charpos+1)+"]"); 
                return false; 
              }//if 
              break; 
           }//case alphanumeric 
        case "num": 
        case "numeric": 
           { 
              var charpos = objValue.value.search("[^0-9]"); 
              if(objValue.value.length > 0 &&  charpos >= 0) 
              { 
                if(!strError || strError.length ==0) 
                { 
                  strError = objValue.name+": Only digits allowed "; 
                }//if               
                alert(strError + "\n [Error character position " + eval(charpos+1)+"]"); 
                return false; 
              }//if 
              break;               
           }//numeric 
		case "odd":
			{
				if(isNaN(objValue.value)) 
				{ 
				  alert(objValue.name+": Should be a number. "); 
				  return false; 
				}//if 
				 if(eval(objValue.value) % 2 == 0) 
				 { 
				   if(!strError || strError.length ==0) 
				   { 
					 strError = objValue.name + " :  Only odd number allowed "; 
				   }//if               
				   alert(strError); 
				   return false;                 
				 }//if             
			  break;
			}
		case "even":
			{
				if(isNaN(objValue.value)) 
				{ 
				  alert(objValue.name+": Should be a number "); 
				  return false; 
				}//if 
				 if(eval(objValue.value) % 2 == 1) 
				 { 
				   if(!strError || strError.length ==0) 
				   { 
					 strError = objValue.name + " :  Only even number allowed "; 
				   }//if               
				   alert(strError); 
				   return false;                 
				 }//if             
				break;
			}
        case "alphabetic": 
        case "alpha": 
           { 
              var charpos = objValue.value.search("[^A-Za-z]"); 
              if(objValue.value.length > 0 &&  charpos >= 0) 
              { 
                  if(!strError || strError.length ==0) 
                { 
                  strError = objValue.name+": Only alphabetic characters allowed "; 
                }//if                             
                alert(strError + "\n [Error character position " + eval(charpos+1)+"]"); 
                return false; 
              }//if 
              break; 
           }//alpha 
        case "email": 
          { 
               if(!validateEmail(objValue.value)) 
               { 
                 if(!strError || strError.length ==0) 
                 { 
                    strError = objValue.name+": Enter a valid Email address "; 
                 }//if                                               
                 alert(strError); 
                 return false; 
               }//if 
           break; 
          }//case email 
        case "lt": 
        case "lessthan": 
         { 
            if(isNaN(objValue.value)) 
            { 
              alert(objValue.name+": Should be a number "); 
              return false; 
            }//if 
            if(eval(objValue.value) >=  eval(cmdvalue)) 
            { 
              if(!strError || strError.length ==0) 
              { 
                strError = objValue.name + " : value should be less than "+ cmdvalue; 
              }//if               
              alert(strError); 
              return false;                 
             }//if             
            break; 
         }//case lessthan 
        case "gt": 
        case "greaterthan": 
         { 
            if(isNaN(objValue.value)) 
            { 
              alert(objValue.name+": Should be a number "); 
              return false; 
            }//if 
             if(eval(objValue.value) <=  eval(cmdvalue)) 
             { 
               if(!strError || strError.length ==0) 
               { 
                 strError = objValue.name + " : value should be greater than "+ cmdvalue; 
               }//if               
               alert(strError); 
               return false;                 
             }//if             
            break; 
         }//case greaterthan 
        case "regexp": 
         { 
            if(!objValue.value.match(cmdvalue)) 
            { 
              if(!strError || strError.length ==0) 
              { 
                strError = objValue.name+": Invalid characters found "; 
              }//if                                                               
              alert(strError); 
              return false;                   
            }//if 
           break; 
         }//case regexp 
        case "dontselect": 
         { 
            if(objValue.selectedIndex == null) 
            { 
              alert("BUG: dontselect command for non-select Item"); 
              return false; 
            } 
            if(objValue.selectedIndex == eval(cmdvalue)) 
            { 
             if(!strError || strError.length ==0) 
              { 
              strError = objValue.name+": Please Select one option "; 
              }//if                                                               
              alert(strError); 
              return false;                                   
             } 
             break; 
         }//case dontselect 
		case "date":
		{
		   var  strInputFormat  = "dMMMy"; 
		   var  strOutputFormat = "dMMMy"; 
			if (cmdvalue != ""){
				strInputFormat = getFirstPart(cmdvalue, ".");
				if (getNextPart(cmdvalue, ".") != ""){
					strOutputFormat = getNextPart(cmdvalue, ".");
				}
				else{
					strOutputFormat = strInputFormat;
				}
		   }
		   var nMilSecs = getDateFromFormat(objValue.value, strInputFormat);
		   if (nMilSecs<=0){
		    if(!strError || strError.length ==0) 
		     { 
				if (nMilSecs<0)
					strError = objValue.name +": This is a non-existant date. "; 
				else
					strError = objValue.name +": Should be a date. "; 
		     }//if                                                               
		     alert(strError); 
		     return false;                                   
		   }
		   else{			
			objValue.value = formatDate(new Date(getDateFromFormat(objValue.value, strInputFormat)), strOutputFormat);
		   }
			break;
		}//case date
		case "ign":
		case "ignoreddays":
		{
		   var  strIgnoreDays = "";
		   var  strTmp = "";
		   var  strInputFormat  = "dMMMy"; 
		   var  strOutputFormat = "dMMMy"; 
			if (cmdvalue != ""){
				strIgnoreDays = getFirstPart(cmdvalue, ".");
				strTmp = getNextPart(cmdvalue, ".");
				if (strTmp != ""){
					if (getFirstPart(strTmp, ".") != ""){
						strInputFormat = getFirstPart(strTmp, ".");						
						if (getNextPart(strTmp, ".") != ""){
							strOutputFormat = getNextPart(strTmp, ".");
						}
						else{
							strOutputFormat = strInputFormat;
						}
					}
				}
		   }

		   if (!isDate(objValue.value, strInputFormat)){
		    if(!strError || strError.length ==0) 
		     { 
				strError = objValue.name +": Should be a date. "; 
		     }//if                                                               
		     alert(strError); 
		     return false;                                   
		   }
		   else{
		   	var theDate = new Date(getDateFromFormat(objValue.value, strInputFormat));
		   	var strDay = getFirstPart(strIgnoreDays, ",");
		   	strIgnoreDays = getNextPart(strIgnoreDays, ",");
		   	while (strDay!=""){
		   		switch(strDay){
		   		case "0":
		   		case "1":
		   		case "2":
		   		case "3":
		   		case "4":
		   		case "5":
		   		case "6":
		   			if (theDate.getDay() == eval(strDay)){
						if(!strError || strError.length ==0) 
						{ 
							strError = objValue.name +": Should not be " + DAY_NAMES[eval(strDay)]; 
						}//if                                                               
						alert(strError); 
						return false;
		   			}
		   			break;
		   		case "x":
		   			if (theDate.getDate()==25 && theDate.getMonth()==11){
						if(!strError || strError.length ==0) 
						{ 
							strError = objValue.name +": Should not be Christmas Day. "; 
						}//if                                                               
						alert(strError); 
						return false;
		   			}
		   			break;
		   		}
		   		strDay = getFirstPart(strIgnoreDays, ",");
		   		strIgnoreDays = getNextPart(strIgnoreDays, ",");
		   	}
		   	objValue.value = formatDate(new Date(getDateFromFormat(objValue.value, strInputFormat)), strOutputFormat);
		   }
		   break;
		}	// case ignoredays
		case "notin":
		{
            if(isNaN(objValue.value)) 
            { 
              alert(objValue.name+": Should be a number "); 
              return false; 
            }//if 
			if (cmdvalue != ""){
		   		var strMin = getFirstPart(cmdvalue, "-");
		   		var strMax = getNextPart(cmdvalue, "-");
		   		if (!isNaN(strMin) && !isNaN(strMax)){
		   			var nMin = eval(strMin);
		   			var nMax = eval(strMax);
		   			if (nMin > nMax){ // switch
		   				var nTmp = nMin;
		   				nMin = nMax;
		   				nMax = nTmp;
		   			}
		   		}
				if (eval(objValue.value)>=nMin && eval(objValue.value)<=nMax){
					if(!strError || strError.length ==0) 
					{ 
						strError = objValue.name +": Should not be within " + cmdvalue; 
					}//if                                                               
					alert(strError); 
					return false;			
				}
			}
			break;
		}	// case notin
		case "phone":
		{
			if (cmdvalue != ""){
				switch(cmdvalue){
					case "mobile":
					{
						if(!validateMobile(objValue.value)) 
						{ 
						  if(!strError || strError.length ==0) 
						  { 
						     strError = objValue.name+": Please enter a valid mobile number."; 
						  }//if                                               
						  alert(strError); 
						  return false; 
						}//if 	
						break;
					}
					case "landline":
					{
						if(!validateLandline(objValue.value)) 
						{ 
						  if(!strError || strError.length ==0) 
						  { 
						     strError = objValue.name+": Please enter a valid phone number."; 
						  }//if                                               
						  alert(strError); 
						  return false; 
						}//if 	
						break;
					}// phone switch
               }
            }
			break;
		}	// case phone
    }//switch 
    return true; 
} 

/* 
* function validateForm 
* the function that can be used to validate any form 
* returns false if the validation fails; true if success 
* arguments : 
*   objFrm     : the form object 
*   arrObjDesc : an array of objects describing the validations to conduct on each 
*        input item. 
*          The array should consist of one object per input item in the order the input 
*          elements are present in the form. Each object consist of zero or more validation 
*          objects. Each of these validation object is a pair consisting of the validation 
*          descriptor string and an optional Error message. 
*/ 
function validateForm(objFrm,arrObjDesc) 
{ 
 for(var itrobj=0; itrobj < arrObjDesc.length; itrobj++) 
 {  
   if(objFrm.elements.length <= itrobj) 
   { 
        alert("BUG: Obj descriptor for a non existent form element"); 
        return false; 
   }//if 
   for(var itrdesc=1; itrdesc < arrObjDesc[itrobj].length ;itrdesc++) 
   { 
      //if(validateData(arrObjDesc[itrobj][itrdesc][0], 
       //          objFrm[itrobj],arrObjDesc[itrobj][itrdesc][1]) == false) 
	   var objDest = objFrm[arrObjDesc[itrobj][0]];
	   if (objDest){
		   if(validateData(arrObjDesc[itrobj][itrdesc][0], 
						objDest,arrObjDesc[itrobj][itrdesc][1]) == false) 
		   { 
			 objDest.focus();
			 return false; 
		   }//if 
	   }
   }//for 
 }//for 
 return true;
} 


/* 
* function validateItem 
* the function that can be used to validate specified item 
* returns false if the validation fails; true if success 
* arguments : 
*   objDest    : the object to be validated
*   arrObjItem : an object describing the validations to conduct on the specifid item
*/ 
function validateItem(objDest, arrObjItem)
{
   for(var itrdesc=1; itrdesc < arrObjItem.length ;itrdesc++) 
   { 
      if(validateData(arrObjItem[itrdesc][0], 
                 objDest,arrObjItem[itrdesc][1]) == false) 
       { 
	     objDest.focus();
         return false; 
       }//if 
   }//for 
}


//-----------------------------------------------------------------------------------
/*				Date Validation Module
*/
//-----------------------------------------------------------------------------------

// The format string consists of the following abbreviations:
// 
// Field        | Full Form          | Short Form
// -------------+--------------------+-----------------------
// Year         | yyyy (4 digits)    | yy (2 digits), y (2 or 4 digits)
// Month        | MMM (name or abbr.)| MM (2 digits), M (1 or 2 digits)
//              | NNN (abbr.)        |
// Day of Month | dd (2 digits)      | d (1 or 2 digits)
// Day of Week  | EE (name)          | E (abbr)
// Hour (1-12)  | hh (2 digits)      | h (1 or 2 digits)
// Hour (0-23)  | HH (2 digits)      | H (1 or 2 digits)
// Hour (0-11)  | KK (2 digits)      | K (1 or 2 digits)
// Hour (1-24)  | kk (2 digits)      | k (1 or 2 digits)
// Minute       | mm (2 digits)      | m (1 or 2 digits)
// Second       | ss (2 digits)      | s (1 or 2 digits)
// AM/PM        | a                  |
//
// NOTE THE DIFFERENCE BETWEEN MM and mm! Month=MM, not mm!
// Examples:
//  "MMM d, y" matches: January 01, 2000
//                      Dec 1, 1900
//                      Nov 20, 00
//  "M/d/yy"   matches: 01/20/00
//                      9/2/00
//  "MMM dd, yyyy hh:mm:ssa" matches: "January 01, 2000 12:30:45AM"
// ------------------------------------------------------------------

var MONTH_NAMES=new Array('January','February','March','April','May','June','July','August','September','October','November','December','Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec');
var DAY_NAMES=new Array('Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sun','Mon','Tue','Wed','Thu','Fri','Sat');
function LZ(x) {return(x<0||x>9?"":"0")+x}

// ------------------------------------------------------------------
// isDate ( date_string, format_string )
// Returns true if date string matches format of format string and
// is a valid date. Else returns false.
// It is recommended that you trim whitespace around the value before
// passing it to this function, as whitespace is NOT ignored!
// ------------------------------------------------------------------
function isDate(val,format) {
	var date=getDateFromFormat(val,format);
	if (date==0) { return false; }
	return true;
	}

// -------------------------------------------------------------------
// compareDates(date1,date1format,date2,date2format)
//   Compare two date strings to see which is greater.
//   Returns:
//   1 if date1 is greater than date2
//   0 if date2 is greater than date1 of if they are the same
//  -1 if either of the dates is in an invalid format
// -------------------------------------------------------------------
function compareDates(date1,dateformat1,date2,dateformat2) {
	var d1=getDateFromFormat(date1,dateformat1);
	var d2=getDateFromFormat(date2,dateformat2);
	if (d1==0 || d2==0) {
		return -1;
		}
	else if (d1 > d2) {
		return 1;
		}
	return 0;
	}

// ------------------------------------------------------------------
// formatDate (date_object, format)
// Returns a date in the output format specified.
// The format string uses the same abbreviations as in getDateFromFormat()
// ------------------------------------------------------------------
function formatDate(date,format) {
	format=format+"";
	var result="";
	var i_format=0;
	var c="";
	var token="";
	var y=date.getYear()+"";
	var M=date.getMonth()+1;
	var d=date.getDate();
	var E=date.getDay();
	var H=date.getHours();
	var m=date.getMinutes();
	var s=date.getSeconds();
	var yyyy,yy,MMM,MM,dd,hh,h,mm,ss,ampm,HH,H,KK,K,kk,k;
	// Convert real date parts into formatted versions
	var value=new Object();
	if (y.length < 4) {y=""+(y-0+1900);}
	value["y"]=""+y;
	value["yyyy"]=y;
	value["yy"]=y.substring(2,4);
	value["M"]=M;
	value["MM"]=LZ(M);
	value["MMM"]=MONTH_NAMES[M-1];
	value["NNN"]=MONTH_NAMES[M+11];
	value["d"]=d;
	value["dd"]=LZ(d);
	value["E"]=DAY_NAMES[E+7];
	value["EE"]=DAY_NAMES[E];
	value["H"]=H;
	value["HH"]=LZ(H);
	if (H==0){value["h"]=12;}
	else if (H>12){value["h"]=H-12;}
	else {value["h"]=H;}
	value["hh"]=LZ(value["h"]);
	if (H>11){value["K"]=H-12;} else {value["K"]=H;}
	value["k"]=H+1;
	value["KK"]=LZ(value["K"]);
	value["kk"]=LZ(value["k"]);
	if (H > 11) { value["a"]="PM"; }
	else { value["a"]="AM"; }
	value["m"]=m;
	value["mm"]=LZ(m);
	value["s"]=s;
	value["ss"]=LZ(s);
	while (i_format < format.length) {
		c=format.charAt(i_format);
		token="";
		while ((format.charAt(i_format)==c) && (i_format < format.length)) {
			token += format.charAt(i_format++);
			}
		if (value[token] != null) { result=result + value[token]; }
		else { result=result + token; }
		}
	return result;
	}
	
// ------------------------------------------------------------------
// Utility functions for parsing in getDateFromFormat()
// ------------------------------------------------------------------
function _isInteger(val) {
	var digits="1234567890";
	for (var i=0; i < val.length; i++) {
		if (digits.indexOf(val.charAt(i))==-1) { return false; }
		}
	return true;
	}
function _getInt(str,i,minlength,maxlength) {
	for (var x=maxlength; x>=minlength; x--) {
		var token=str.substring(i,i+x);
		if (token.length < minlength) { return null; }
		if (_isInteger(token)) { return token; }
		}
	return null;
	}
	
// ------------------------------------------------------------------
// getDateFromFormat( date_string , format_string )
//
// This function takes a date string and a format string. It matches
// If the date string matches the format string, it returns the 
// getTime() of the date. If it does not match, it returns 0.
// ------------------------------------------------------------------
function getDateFromFormat(val,format) {
	val=val+"";
	format=format+"";
	var i_val=0;
	var i_format=0;
	var c="";
	var token="";
	var token2="";
	var x,y;
	var now=new Date();
	var year=now.getYear();
	var month=now.getMonth()+1;
	var date=1;
	var hh=now.getHours();
	var mm=now.getMinutes();
	var ss=now.getSeconds();
	var ampm="";
	
	while (i_format < format.length) {
		// Get next token from format string
		c=format.charAt(i_format);
		token="";
		while ((format.charAt(i_format)==c) && (i_format < format.length)) {
			token += format.charAt(i_format++);
			}
		// Extract contents of value based on format token
		if (token=="yyyy" || token=="yy" || token=="y") {
			if (token=="yyyy") { x=4;y=4; }
			if (token=="yy")   { x=2;y=2; }
			if (token=="y")    { x=2;y=4; }
			year=_getInt(val,i_val,x,y);
			if (year==null) { return 0; }
			i_val += year.length;
			if (year.length==2) {
				if (year > 70) { year=1900+(year-0); }
				else { year=2000+(year-0); }
				}
			}
		else if (token=="MMM"||token=="NNN"){
			month=0;
			for (var i=0; i<MONTH_NAMES.length; i++) {
				var month_name=MONTH_NAMES[i];
				if (val.substring(i_val,i_val+month_name.length).toLowerCase()==month_name.toLowerCase()) {
					if (token=="MMM"||(token=="NNN"&&i>11)) {
						month=i+1;
						if (month>12) { month -= 12; }
						i_val += month_name.length;
						break;
						}
					}
				}
			if ((month < 1)||(month>12)){return 0;}
			}
		else if (token=="EE"||token=="E"){
			for (var i=0; i<DAY_NAMES.length; i++) {
				var day_name=DAY_NAMES[i];
				if (val.substring(i_val,i_val+day_name.length).toLowerCase()==day_name.toLowerCase()) {
					i_val += day_name.length;
					break;
					}
				}
			}
		else if (token=="MM"||token=="M") {
			month=_getInt(val,i_val,token.length,2);
			if(month==null||(month<1)||(month>12)){return 0;}
			i_val+=month.length;}
		else if (token=="dd"||token=="d") {
			date=_getInt(val,i_val,token.length,2);
			if(date==null||(date<1)||(date>31)){return 0;}
			i_val+=date.length;}
		else if (token=="hh"||token=="h") {
			hh=_getInt(val,i_val,token.length,2);
			if(hh==null||(hh<1)||(hh>12)){return 0;}
			i_val+=hh.length;}
		else if (token=="HH"||token=="H") {
			hh=_getInt(val,i_val,token.length,2);
			if(hh==null||(hh<0)||(hh>23)){return 0;}
			i_val+=hh.length;}
		else if (token=="KK"||token=="K") {
			hh=_getInt(val,i_val,token.length,2);
			if(hh==null||(hh<0)||(hh>11)){return 0;}
			i_val+=hh.length;}
		else if (token=="kk"||token=="k") {
			hh=_getInt(val,i_val,token.length,2);
			if(hh==null||(hh<1)||(hh>24)){return 0;}
			i_val+=hh.length;hh--;}
		else if (token=="mm"||token=="m") {
			mm=_getInt(val,i_val,token.length,2);
			if(mm==null||(mm<0)||(mm>59)){return 0;}
			i_val+=mm.length;}
		else if (token=="ss"||token=="s") {
			ss=_getInt(val,i_val,token.length,2);
			if(ss==null||(ss<0)||(ss>59)){return 0;}
			i_val+=ss.length;}
		else if (token=="a") {
			if (val.substring(i_val,i_val+2).toLowerCase()=="am") {ampm="AM";}
			else if (val.substring(i_val,i_val+2).toLowerCase()=="pm") {ampm="PM";}
			else {return 0;}
			i_val+=2;}
		else {
			if (val.substring(i_val,i_val+token.length)!=token) {return 0;}
			else {i_val+=token.length;}
			}
		}
	// If there are any trailing characters left in the value, it doesn't match
	if (i_val != val.length) { return 0; }
	// Is date valid for month?	
	if (month==2) {
		// Check for leap year
		if ( ( (year%4==0)&&(year%100 != 0) ) || (year%400==0) ) { // leap year
			if (date > 29){ return -100; }
			}
		else { if (date > 28) { 
			return -100; } }
		}
	if ((month==4)||(month==6)||(month==9)||(month==11)) {
		if (date > 30) { return 0; }
		}
	// Correct hours value
	if (hh<12 && ampm=="PM") { hh=hh-0+12; }
	else if (hh>11 && ampm=="AM") { hh-=12; }
	var newdate=new Date(year,month-1,date,hh,mm,ss);
	return newdate.getTime();
	}

// ------------------------------------------------------------------
// parseDate( date_string [, prefer_euro_format] )
//
// This function takes a date string and tries to match it to a
// number of possible date formats to get the value. It will try to
// match against the following international formats, in this order:
// y-M-d   MMM d, y   MMM d,y   y-MMM-d   d-MMM-y  MMM d
// M/d/y   M-d-y      M.d.y     MMM-d     M/d      M-d
// d/M/y   d-M-y      d.M.y     d-MMM     d/M      d-M
// A second argument may be passed to instruct the method to search
// for formats like d/M/y (european format) before M/d/y (American).
// Returns a Date object or null if no patterns match.
// ------------------------------------------------------------------
function parseDate(val) {
	var preferEuro=(arguments.length==2)?arguments[1]:false;
	generalFormats=new Array('y-M-d','MMM d, y','MMM d,y','y-MMM-d','d-MMM-y','MMM d');
	monthFirst=new Array('M/d/y','M-d-y','M.d.y','MMM-d','M/d','M-d');
	dateFirst =new Array('d/M/y','d-M-y','d.M.y','d-MMM','d/M','d-M');
	var checkList=new Array('generalFormats',preferEuro?'dateFirst':'monthFirst',preferEuro?'monthFirst':'dateFirst');
	var d=null;
	for (var i=0; i<checkList.length; i++) {
		var l=window[checkList[i]];
		for (var j=0; j<l.length; j++) {
			d=getDateFromFormat(val,l[j]);
			if (d!=0) { return new Date(d); }
			}
		}
	return null;
	}

// ------------------------------------------------------------------
/*
LTrim(string) : Returns a copy of a string without leading spaces.
   PURPOSE: Remove leading blanks from our string.
   IN: str - the string we want to LTrim
*/
// ------------------------------------------------------------------
function LTrim(str)
{
   var whitespace = new String(" \t\n\r");

   var s = new String(str);

   if (whitespace.indexOf(s.charAt(0)) != -1) {
      // We have a string with leading blank(s)...

      var j=0, i = s.length;

      // Iterate from the far left of string until we
      // don't have any more whitespace...
      while (j < i && whitespace.indexOf(s.charAt(j)) != -1)
         j++;

      // Get the substring from the first non-whitespace
      // character to the end of the string...
      s = s.substring(j, i);
   }
   return s;
}

// ------------------------------------------------------------------
/*
RTrim(string) : Returns a copy of a string without trailing spaces.
   PURPOSE: Remove trailing blanks from our string.
   IN: str - the string we want to RTrim
*/
// ------------------------------------------------------------------
function RTrim(str)
{
   // We don't want to trip JUST spaces, but also tabs,
   // line feeds, etc.  Add anything else you want to
   // "trim" here in Whitespace
   var whitespace = new String(" \t\n\r");

   var s = new String(str);

   if (whitespace.indexOf(s.charAt(s.length-1)) != -1) {
      // We have a string with trailing blank(s)...

      var i = s.length - 1;       // Get length of string

      // Iterate from the far right of string until we
      // don't have any more whitespace...
      while (i >= 0 && whitespace.indexOf(s.charAt(i)) != -1)
         i--;


      // Get the substring from the front of the string to
      // where the last non-whitespace character is...
      s = s.substring(0, i+1);
   }

   return s;
}

// ------------------------------------------------------------------
/*
Trim(string) : Returns a copy of a string without leading or trailing spaces
   PURPOSE: Remove trailing and leading blanks from our string.
   IN: str - the string we want to Trim
   RETVAL: A Trimmed string!
*/
// ------------------------------------------------------------------
function Trim(str)
{
   return RTrim(LTrim(str));
}

function replaceAll( str, from, to ) {
    var idx = str.indexOf( from );

    while ( idx > -1 ) {
        str = str.replace( from, to ); 
        idx = str.indexOf( from );
    }

    return str;
}