function IR_LeftTrimExtended(IR_cString, IR_cChar) 
	{
		 var a = 0;
		 var b = IR_cString.length;
		 var c = '';
		 
		 while((a < b) && (IR_cString.charAt(a) == IR_cChar)) a++;
		 	if (a < b) c = IR_cString.substring(a, b);

		 return c;
	}

	function IR_LeftTrim(IR_cString)
	{
		var IR_x;
		var IR_nLength;
		var IR_cReturnString = '';

		if (IR_cString != null)
		{
			IR_nLength = IR_cString.length;
	
			for(IR_x = 0; IR_x < IR_nLength; IR_x++)
			{
				if(IR_cString.charAt(IR_x) != ' ')
					break;
			}
	
			if(IR_x < IR_nLength)
				IR_cReturnString = IR_cString.substring(IR_x, IR_nLength);
		}
		
		return IR_cReturnString;
	}

	function IR_RightTrim(IR_cString)
	{
		var IR_x;
		var IR_nLength;
		var IR_cReturnString = '';

		if (IR_cString != null)
		{
			IR_nLength = IR_cString.length;
	
			for(IR_x = IR_nLength-1; IR_x >= 0; IR_x--)
			{
				if(IR_cString.charAt(IR_x) != ' ')
					break;
			}
	
			if(IR_x >= 0)
				IR_cReturnString = IR_cString.substring(0, IR_x+1);
		}
		
		return IR_cReturnString;
	}

	function IR_Trim(IR_cString)
	{

		var IR_cReturnString;

		IR_cReturnString = IR_LeftTrim(IR_cString);
		IR_cReturnString = IR_RightTrim(IR_cReturnString);

		return IR_cReturnString;
	}

	function IR_StrReverse(IR_cInputString)
	{
		var IR_cOutputString = '';
		var IR_nLength = IR_cInputString.length - 1;
		var IR_x;

		if(IR_nLength >= 0)
		{
			for(IR_x = IR_nLength; IR_x >= 0; IR_x--)
				IR_cOutputString = IR_cOutputString + IR_cInputString.charAt(IR_x);
		}

		return IR_cOutputString;
	}

	function IR_StrInsert(IR_cInputString, IR_cStrToInsert, IR_nAverage, IR_bFromLeft)
	{
		var IR_cInString = IR_cInputString;
		var IR_cOutputString = '';
		var IR_nLength = IR_cInputString.length;
		var IR_x;

		if(IR_nLength > 0)
		{
			if(!IR_bFromLeft)
				IR_cInString = IR_StrReverse(IR_cInString)

			for(IR_x = 0; IR_x < IR_nLength; IR_x++)
			{
				if(IR_x && ((IR_x % IR_nAverage) == 0))
					IR_cOutputString = IR_cOutputString + IR_cStrToInsert;

				IR_cOutputString = IR_cOutputString + IR_cInString.charAt(IR_x);
			}

			if(!IR_bFromLeft)
				IR_cOutputString = IR_StrReverse(IR_cOutputString)
		}

		return IR_cOutputString;
	}

	function IR_StrPad(IR_cInputString, IR_cStrToInsert, IR_nCount, IR_bFromLeft)
	{
		var IR_cOutputString = IR_cInputString;
		var IR_nLength = IR_cInputString.length;
		var IR_x;

		if(IR_nLength > 0)
		{
			if(IR_bFromLeft)
				IR_cOutputString = IR_StrReverse(IR_cOutputString)

			for(IR_x = 0; IR_x < IR_nCount; IR_x++)
				IR_cOutputString = IR_cOutputString + IR_cStrToInsert;

			if(IR_bFromLeft)
				IR_cOutputString = IR_StrReverse(IR_cOutputString)
		}

		return IR_cOutputString;
	}

	/**
	 * Verifica la validità della stringa in base alla maschera definita.
	 * Restituisce true in caso di stringa valida, false altrimenti
	 * @param IR_cString Stringa
	 * @param IR_nFrom Inizio stringa in Numerico
	 * @param IR_nTo Fine stringa in Numerico
	 * @param IR_cMask Maschera di controllo in Stringa
	 * @return IR_bIsValid Booleano
	 * <BR><B>Es di utilizzo:</B> IR_IsValidString('+250520.04',0,9,'1234567890+-');
	 * <BR>&nbsp;&nbsp;&nbsp;Il Risultato è: IR_bIsValid = false
	 */     
	function IR_IsValidString(IR_cString, IR_nFrom,IR_nTo,IR_cMask)
	{
	    var IR_i;
	    var IR_j;
	    var IR_ch;
	    var IR_bIsValid;
	    IR_bIsValid = true;
	
	    for(IR_i = IR_nFrom;  IR_i < IR_nTo;  IR_i++)
	    {
	        IR_ch = IR_cString.charAt(IR_i);
	        for(IR_j = 0;  IR_j < IR_cMask.length;  IR_j++)
	        {
	            if(IR_ch == IR_cMask.charAt(IR_j))
	                break;
	        }
	        if(IR_j == IR_cMask.length)
	        {
	            IR_bIsValid = false;
	            break;
	        }
	    }
	    return IR_bIsValid;
	}

	var NUMERO_INTERO = '1234567890';
	
	function IR_IsStringOfDigits(IR_cString, IR_nFrom, IR_nTo)
	{
		return IR_IsValidString(IR_cString, IR_nFrom, IR_nTo, NUMERO_INTERO);
	}

	/**
	 * Verifica la validità della stringa in base alla maschera definita (solo numeri interi).
	 * Restituisce true in caso di stringa valida, false altrimenti
	 * @param IR_cString Stringa
	 * @param IR_nFrom Inizio stringa in Numerico
	 * @param IR_nTo Fine stringa in Numerico
	 * @return Booleano
	 * <BR><B>Es di utilizzo:</B> IR_IsNumber('2514689',0,6);
	 * <BR>&nbsp;&nbsp;&nbsp;Il Risultato è: true
	 */     
	function IR_IsNumber(IR_cString,IR_nFrom,IR_nTo)
	{
	  return IR_IsValidString(IR_cString, IR_nFrom, IR_nTo, NUMERO_INTERO);
	}

	function IR_IsNumberNotNull(IR_cString, IR_nFrom, IR_nTo)
	{
		if(parseInt(IR_cString, 10) == 0)
			return false;
		else
			return IR_IsNumber(IR_cString, IR_nFrom, IR_nTo);
	}

	function IR_IsImporto(IR_cString, IR_nFrom, IR_nTo)
	{

		//IR_### if(IR_cString == "0")
			//IR_### return false;
		//IR_### else


		return IR_IsValidString(IR_cString, IR_nFrom, IR_nTo, NUMERO_INTERO + '.,');
	}

	function IR_IsNumericString(IR_cString, IR_nFrom, IR_nTo)
	{
		return IR_IsValidString(IR_cString, IR_nFrom, IR_nTo, NUMERO_INTERO + '+-.,--');
	}

	function IR_IsAlphabeticString(IR_cString, IR_nFrom, IR_nTo)
	{

		return IR_IsValidString(IR_cString, IR_nFrom, IR_nTo, 'ABCDEFGHILMNOPQRSTUVZWXYJKabcdefghilmnopqrstuvzwxyjk');
		//alert("ci passo");
	}

	function IR_IsAlphabeticStringConAsterisco(IR_cString, IR_nFrom, IR_nTo)
	{
		return IR_IsValidString(IR_cString, IR_nFrom, IR_nTo, "ABCDEFGHILMNOPQRSTUVZWXYJKabcdefghilmnopqrstuvzwxyjkàèéòì' *");
		//alert("ci passo");
	}

	function IR_IsAlphabeticStringSpecial(IR_cString, IR_nFrom, IR_nTo)
	{
		return IR_IsValidString(IR_cString, IR_nFrom, IR_nTo, "ABCDEFGHILMNOPQRSTUVZWXYJKabcdefghilmnopqrstuvzwxyjkàèéòìù '");
		//alert("ci passo");
	}

	function IR_IsAlphanumericString(IR_cString, IR_nFrom, IR_nTo)
	{
		return IR_IsValidString(IR_cString, IR_nFrom, IR_nTo, "ABCDEFGHILMNOPQRSTUVZWXYJKabcdefghilmnopqrstuvzwxyjkàèéòì' 0123456789");
		//alert("ci passo");
	}

	//silvia inizio modifica 03/12
	//funzione nuova che serve per il controllo sulla denominazione per i Soggetti Giuridici
	//in quanto posso inserire caratteri numerici, stringhe e punteggiatura
	function IR_IsAlphanumericPunteggiaturaString(IR_cString, IR_nFrom, IR_nTo)
	{
		return IR_IsValidString(IR_cString, IR_nFrom, IR_nTo, "ABCDEFGHILMNOPQRSTUVZWXYJKabcdefghilmnopqrstuvzwxyjkàèéòì' *0123456789&.,");
		//alert("ci passo");
	}
	//silvia fine modifica 03/12

	function IR_GetValoreSubString(IR_cStringa, IR_cSeparators)
	{
		var IR_nPosSeparator

		IR_nPosSeparator = IR_cStringa.search(IR_cSeparators);

		if(IR_nPosSeparator == -1)
		{
			IR_nPosSeparator = IR_cStringa.length
		}

		IR_cStringa = IR_cStringa.substring(0, IR_nPosSeparator);

		return IR_cStringa;
	}

	//IR_### La funzione rimuove dalla stringa (primo parametro) i caratteri consecutivi (secondo parametro).
	function IR_MoveCharsFromString(IR_cString, IR_cChars) {
		var IR_cResult = "";
		var IR_charSearch = IR_cChars.charAt(0);
		var lenChars = 0;
		var IR_Temp = "";

		for(IR_x=0; IR_x<IR_cString.length; IR_x++) {
		  if(IR_cString.charAt(IR_x)!=IR_charSearch)
		     IR_cResult=IR_cResult+ IR_cString.charAt(IR_x);
		  else {
		     lenChars = IR_x + IR_cChars.length;
		     IR_Temp =IR_cString.substring(IR_x,lenChars);
		     if(IR_Temp.toLowerCase()==IR_cChars.toLowerCase()) {
  		     	IR_cResult= IR_cResult + " ";
  		     	IR_x = lenChars-1;
		     }
		     else
		     	IR_cResult=IR_cResult+ IR_cString.charAt(IR_x);
		  }
		}
		return IR_cResult;
	}

	// Sostituisce con il carattere aNewChar tutte le occorrenze del carattere aOldChar
	// trovate nella stringa aString
	function replaceChar(aString, aOldChar, aNewChar)
	{		
		var aBuf = "";
		var i;

		for(i = 0; i < aString.length; i++ )
		{
			if(aString.charAt(i) == aOldChar.charAt(0))
				aBuf = aBuf + aNewChar;
			else
				aBuf = aBuf + aString.charAt(i);
		}
			
		return aBuf;
	}
	
	// Sostituisce con newStr tutte le occorrenze della stringa oldStr trovate nella stringa sStringa
	function replaceAll(sStringa, oldStr, newStr) 
	{
 	    var buf = "";
 	    var idSrch = 0;  
 	     	    
	    while (sStringa.indexOf(oldStr,idSrch) != -1)  
	    {
	        buf += sStringa.substring(idSrch,sStringa.indexOf(oldStr,idSrch));
	        buf += newStr;
	        idSrch = (sStringa.indexOf(oldStr,idSrch) + oldStr.length);
  	    }
	    
	    buf += sStringa.substring(idSrch,sStringa.length);

	    return buf;
	}	

	// Conta quante istanze del carattere IR_char sono presenti nella stringa IR_cString
	function IR_ContaIstanzeChar(IR_cString, IR_cChar) 
	{
		var i;
		var nCount = 0;
		for(i = 0; i < IR_cString.length; i++ )
		{
			if(IR_cString.charAt(i) == IR_cChar)
				nCount++;
		}
		return nCount;
	}
	
	// Conta quanti elementi diversi dalla stringa vuota ci sono nella stringa in analisi; 
	// ogni elemento e' separato dal successivo mediante il carattere IR_char
	function IR_ContaIstanzeDelimited(IR_cString, IR_cChar) 
	{
		var i;
		var nC = 0;
		var readySh = false;
		
		IR_cString = IR_Trim(IR_cString);
		if(IR_cString.length == 0)
			return 0;
		else
		{
			if(IR_cString.charAt(0) != IR_cChar)
				nC++;
				
			for(i=0; i < IR_cString.length; i++)
			{
				if(IR_cString.charAt(i) == IR_cChar)
   				    readySh = true;
   				else
   				{
   					if(readySh)
   						nC++;
   					
      				readySh = false;
   				}
			}
			
			return nC;
		}
	}

	// In una stringa composta da n-elementi separati dal carattere IR_ChSeparator
	// rende quello che ha indice IR_index (primo elemento con indice 1), se esiste.
	// Diversamente rende la stringa vuota
	function IR_getStringElement(IR_cString, IR_index, IR_ChSeparator)
	{
		if(IR_cString.length > 0)
		{
			var i;
			var buf = '';
			var nC = 1;
			var readySh = false;
			
			IR_cString = IR_Trim(IR_cString);
			if(IR_cString.length > 0)
			{
				for(i=0; i < IR_cString.length; i++)
				{
					if(IR_cString.charAt(i) == IR_ChSeparator)
					{		   					
	   				    readySh = true;
	   				    
	   				    if(IR_index == nC)
	   				         return buf;
	   				         
	   				    buf = '';
	   				}
	   				else
	   				{
	   					if(readySh)	   					
	   					{
	   						nC++;	   					
        				    readySh = false;
        				}
	      				
	      				buf = buf + IR_cString.charAt(i);
	   				}
				}
			}
			
			if(nC == IR_index)
   			    return buf;				
		}
		
   		return '';	
	}
	
	// Rende true se la stringa sString passata in ingresso inizia con la stringa sWith
	function IR_startsWith(sString, sWith)
	{
	  if((sString == '') || (sWith == ''))
	  	  return false;

	  return (sString.substring(0, sWith.length) == sWith);
	}

    // Rende true se la stringa sString passata in ingresso termina con la stringa sWith
	function IR_endsWith(sString, sWith)
	{
	  if((sString == '') || (sWith == ''))
	  	  return false;
	  	  
	  return IR_startsWith(IR_StrReverse(sString), IR_StrReverse(sWith));
	}
	
	
    // Restituisce la sottostringa di sString che parte dalla posizione 0
    // e ha come ultimo carattere quello prima della sNumOccurrence-occorrenza
    // di sSeparator
	function IR_substringExtended(sString, sSeparator, sNumOccurrence)
	{
 	  if((sString != '') && (sSeparator != ''))
 	  {
		  var i = 0;
		  var sepCounter = 0;
		  var sBuffer = '';
		  
		  for(i=0; (i < sString.length) && (sepCounter < sNumOccurrence); i++)
		  {
		      if(sString.charAt(i) == sSeparator)
		          sepCounter++;
			  
			  if(sepCounter < sNumOccurrence)			  		          
    		      sBuffer = sBuffer + sString.charAt(i);
		  } 	  
 	  
 	      return sBuffer;
 	  }
 	  
 	  return "";
	}