// ----------------------------------------------------------
//    Devuelve una cadena con el formato Oracle indicado
//      Se añadirán a la cadena los caracteres que vayan en el formato encerrados entre comillas ("")
//      Devuelve una cadena con el formato Oracle indicado o null si es incorrecto.
//-----
function conFormatoOracle(cCadena, cFormato, cCampoErr) {
  var cResul   = "";
  var lLiteral = false;
  var nPosC    = 0;
  var cCar;

  do {
    if (cFormato == null) { cResul = cCadena; break; }
    if (esFormatoFijo(cCadena, cFormato, cCampoErr)) { cResul = cCadena; break; }
    
    for (nPosF = 0; nPosF < cFormato.length; nPosF++) {
      cCar = cFormato.charAt(nPosF);
      if (cCar == '"') {
        lLiteral = !lLiteral;
        continue;
      }

      if (nPosC > cCadena.length)  { cResul = null; break; }
      
      cCar = ( (lLiteral) ? cFormato.charAt(nPosF) : cCadena.charAt(nPosC++) )
      cResul += cCar;
    }

    if ( (nPosC) != cCadena.length ) cResul = null

  } while (false);
  
  if (cResul == null) if (cCampoErr != null) agregaMensaje("G0001", cCampoErr + " no tiene el formato adecuado (" + cFormato + ")"); 

  return cResul;
}

// ----------------------------------------------------------
//    Devuelve una subcadena con los caracteres indicados por la derecha
//-----
function derecha(cCadena, nCuantos) {
  nCar = 0;
  nPos = 0;

  nCar = nCuantos;
  if (nCar < 0) nCar = 0;
  if (nCar > cCadena.length) nCar = cCadena.length;

  nPos = cCadena.length - nCar;

  return cCadena.substring(nPos, cCadena.length);
}

// ----------------------------------------------------------
//    Devuelve true si la cadena sólo tiene caracteres alfabéticos
//-----
function esAlfabetico(cCadena, cCampoErr) {
	var erLetras	= /^([A-Z]|[a-z])+$/
	var lResul		= erLetras.test(cCadena);	//comprueba que sólo hay letras
	
  if(!lResul) if (cCampoErr != null) agregaMensaje("G0001", cCampoErr + " sólo admite letras entre A y Z (sin eñe)");

  return lResul
}

// ----------------------------------------------------------
//    Devuelve true si la cadena sólo tiene caracteres alfabéticos y/o números
//-----
function esAlfanumerico(cCadena, cCampoErr) {
	var erLetras	= /^([A-Z]|[a-z]|[0-9])+$/
	var lResul		= erLetras.test(cCadena);	//comprueba que sólo hay letras y/o números

  if(!lResul) if (cCampoErr != null) agregaMensaje("G0001", cCampoErr + " sólo admite letras entre A y Z (sin eñe) y números"); 

  return lResul
}

// ----------------------------------------------------------
//    Devuelve true si la cadena sólo tiene caracteres alfabéticos y/o números y/o caracteres extendidos
//-----
function esAlfanumericoEx(cCadena, cCampoErr) {
	var erLetras 	= /^([0-9]|[a-z]|[A-Z]|á|é|í|ó|ú|ñ|Ñ|ü|Á|É|Í|Ó|Ú|[()]|,|\s|\.|\+|-)+$/
	var lResul		= erLetras.test(cCadena);	//comprueba que sólo hay letras y/o números

  if(!lResul) if (cCampoErr != null) agregaMensaje("G0028", cCampoErr); 

  return lResul
}

// ----------------------------------------------------------
//    Devuelve true si la cadena se corresponde con el formato indicado
//-----
function esFormatoFijo(cCadena, cFormato, cCampoErr) {
	var erLetra  = /^([a-z]|[A-Z]|á|é|í|ó|ú|ñ|Ñ|ü|Ü|ç|Ç|Á|É|Í|Ó|Ú)$/
	var erNumero = /[0-9]/
	var lResul   = true;
	var lLiteral = false;
	var nPosC    = 0;
	var nPosF;
	var cCarC;
	var cCarF;
	
	for (nPosF = 0; nPosF < cFormato.length; nPosF++)
	{
		cCarF = cFormato.substr(nPosF, 1);
		if (cCarF == '"') {
			lLiteral = !lLiteral;
			continue;
		}

		cCarC = cCadena.substr(nPosC++, 1);

		if (lLiteral) {
			lResul = (cCarC == cCarF);
		}
		else {
			switch (cCarF) {
				case '0':
				case '9':
					lResul = erNumero.test(cCarC);
					break;
				case 'A':
					lResul = erLetra.test(cCarC);
					break;
			}
		}
	
		if (!lResul) break;
	}
	
  if (lResul) if (nPosC != cCadena.length) lResul = false;
  if (!lResul) if (cCampoErr != null) agregaMensaje("G0001", cCampoErr + " no tiene el formato adecuado (" + cFormato + ")"); 

  return lResul
}

// ----------------------------------------------------------
//    Devuelve una subcadena con los caracteres indicados por la izquierda
//-----
function izquierda(cCadena, nCuantos) {
  nCar = 0;

  nCar = nCuantos;
  if (nCar < 0) nCar = 0;
  if (nCar > cCadena.length) nCar = cCadena.length;

  return cCadena.substring(0, nCar);
}

// ----------------------------------------------------------
//    Devuelve una cadena transformada con letras capitales
//-----
function letraCapital(cCadena, lMinusculas) 
{
	var erPalabras = /([\S]+[A-Za-zñÑáéíóúÁÉÍÓÚüÜ]+)/g;
	var cCapital   = cCadena;

	if (typeof lMinusculas == "undefined") lMinusculas = true;
	if (lMinusculas) cCapital = cCapital.toLowerCase();
	
	cCapital = cCapital.replace(erPalabras, 
	                            function($0) { 
                                return($0.charAt(0).toUpperCase() + $0.slice(1))
												  		})
	return cCapital;
}

// ----------------------------------------------------------
//    Devuelve una cadena transformada con letras capitales, salvo las indicadas en el array
//-----
function letraCapitalEx(cCadena, cEx, lMinusculas) 
{
	var aPalabras;
	var aEx       = cEx.split(" ");
	var cPalabra;
	var nI, nJ;
	var lEx;
	var cCapital   = cCadena;

	if (typeof lMinusculas == "undefined") lMinusculas = true;
	if (lMinusculas) cCapital = cCapital.toLowerCase();
	cCapital = cCapital.charAt(0).toUpperCase() + cCapital.slice(1);
	aPalabras = cCapital.split(" ");

	for (nI=0; nI < aPalabras.length; nI++)
	{
		cPalabra = aPalabras[nI];
		lEx = false;
		for (nJ=0; nJ < aEx.length; nJ++)
		{
  		if (cPalabra.toUpperCase() == aEx[nJ].toUpperCase()) {lEx = true; break;}
		}
		if (!lEx)
		{
			cCapital = sustiTexto(cCapital, " " + cPalabra, " " + cPalabra.charAt(0).toUpperCase() + cPalabra.slice(1).toLowerCase());
		}
	}
	
	return cCapital;
}

// ----------------------------------------------------------
//    Devuelve el número de ocurrencias encontradas
//-----
function ocurrencias(cCadena, cBuscar) {
	var nPos0    = 0;
	var nPos9    = 0;
	var nCuantas = 0;

  do {
    nPos9 = cCadena.indexOf(cBuscar, nPos0);
    if (nPos9 > -1) {
      nCuantas++;
      nPos0 = nPos9 + cBuscar.length;
    }
  } while (nPos9 > -1);
  
	return nCuantas;
}

// ----------------------------------------------------------
// 	Función auxiliar para rellenaDer y rellenaIzq
//-----
function rellenar(cLado, cCadena, nLongitud, cRellenar) {
	var cRelleno    = cRellenar;
	var nLonRelleno	= 0;
	
	if ( (cRellenar.length > 0) & (cCadena.length < nLongitud) ) {
		nLonRelleno = nLongitud - cCadena.length;
		while (cRelleno.length < nLonRelleno) { cRelleno += cRellenar; }
		cRelleno = izquierda(cRelleno, nLonRelleno);
		
		if (cLado == "I") {
			cCadena = cRelleno + cCadena;
		} else {
			cCadena += cRelleno;
		}
	}
	
  return cCadena;
}

// ----------------------------------------------------------
// 		Devuelve una cadena rellena con caracteres por la derecha
//-----
function rellenaDer(cCadena, nLongitud, cRellenar) {
	return rellenar("D", cCadena, nLongitud, cRellenar);
}

// ----------------------------------------------------------
// 		Devuelve una cadena rellena con caracteres por la izquierda
//-----
function rellenaIzq(cCadena, nLongitud, cRellenar) {
	return rellenar("I", cCadena, nLongitud, cRellenar);
}

// ----------------------------------------------------------
// 		Devuelve una cadena rellena con caracteres por la izquierda y por la derecha
//-----
function rellenaIzqDer(cCadena, nLongitud, cRellenar) {
	var cResul      = cCadena;
	var nLonCadena  = cCadena.length;
	var nLonRelleno = (nLongitud - nLonCadena);
	
	if (nLonCadena < nLongitud)
	{
		cResul = rellenar("D", cCadena, nLonCadena + (nLonRelleno / 2), cRellenar);
		cResul = rellenar("I", cResul, nLongitud, cRellenar);
	}
	
	return cResul;
}

// ----------------------------------------------------------
// 		Devuelve una cadena después replicada 'n' veces
//-----
function replicar(cCadena, nVeces) {
	var cReplicado = "";
	
	for (nI=1; nI <= nVeces; nI++) { cReplicado += cCadena; }
	
  return cReplicado;
}

// ----------------------------------------------------------
//    Devuelve una cadena después de eliminar los puntos (.)
//-----
function sinPuntos(cCadena) {
	var re = /\./g;
	
	return cCadena.replace(re,"");
}

// ----------------------------------------------------------
//    Devuelve una cadena después de sustituir lo indicado según expresión regular
//-----
function sustiTexto(cCadena, cSusti, cPor) {
	var cAux = escape(cCadena);
	var re 	 = new RegExp(escape(cSusti), "g"); 

	return unescape(cAux.replace(re, cPor));
}

// ----------------------------------------------------------
//    Devuelve una cadena después de sustituir lo indicado
//-----
function sustiPrimera(cCadena, cSusti, cPor) {
  var nPos;
  var cResul  = cCadena;
  
  nPos = cCadena.indexOf(cSusti);
  if (nPos > -1) {
    cResul = cCadena.substr(0, nPos) + cPor + cCadena.substr(nPos + cSusti.length);
  }

  return cResul;
}

// ----------------------------------------------------------
//    Devuelve una cadena después de sustituir lo indicado
//-----
function sustiTodas(cCadena, cSusti, cPor) {
	var nPos0    = 0;
	var nPos9    = 0;
	var nCuantas = 0;
  var nCual    = 0;
  var cResul   = cCadena;
  
  nCuantas = ocurrencias(cCadena, cSusti);
  
  for (nCual = 1; nCual <= nCuantas; nCual++) {
    cResul = sustiUna(cResul, cSusti, cPor, 1);    
  }

  return cResul;
}

// ----------------------------------------------------------
//    Devuelve una cadena después de sustituir lo indicado
//-----
function sustiUltima(cCadena, cSusti, cPor) {
  var nPos;
  var cResul  = cCadena;
  
  nPos = cCadena.lastIndexOf(cSusti);
  if (nPos > -1) {
    cResul = cCadena.substr(0, nPos) + cPor + cCadena.substr(nPos + cSusti.length);
  }

  return cResul;
}

// ----------------------------------------------------------
//    Devuelve una cadena después de sustituir lo indicado
//-----
function sustiUna(cCadena, cSusti, cPor, nCual) {
	var nPos0    = 0;
	var nPos9    = 0;
	var nCuantas = 0;
  var cResul   = cCadena;
  
  do {
    if (nCual > ocurrencias(cCadena, cSusti)) break;
    
    nPos9 = cCadena.indexOf(cSusti, nPos0);
    if (nPos9 > -1) {
      nCuantas++;
      
      if (nCuantas == nCual) {
        cResul = cCadena.substr(0, nPos9) + cPor + cCadena.substr(nPos9 + cSusti.length);
        break;
      }

      nPos0 = nPos9 + cSusti.length;
    }
  } while (nPos9 > -1);

  return cResul;
}

// ----------------------------------------------------------
//    Devuelve una cadena después de realizar el translate habitual de Oracle
//-----
function translateOracle(cCadena) {
  var cCars1  = new String("ÁÉÍÓÚÀÈÌÒÙÄËÏÖÜÂÊÎÔÛáéíóúàèìòùäëïöüâêîôû");
  var cCars2  = new String("AEIOUAEIOUAEIOUAEIOUaeiouaeiouaeiouaeiou");
  var cCar;
  var nPos;
  var cResul  = new String("");
  
  for (nI = 0; nI < cCadena.length; nI++) {
    cCar = cCadena.substr(nI, 1);
    nPos = cCars1.indexOf(cCar);
    if (nPos > -1) cCar = cCars2.substr(nPos, 1);
    cResul += cCar
  }

  return cResul;
}

// ----------------------------------------------------------
//    Devuelve una cadena después de eliminar los espacios por la izquierda
//-----
function lTrim(cCadena) {
	var re = /^(\s+)/g;
	
	return cCadena.replace(re,"");
}

// ----------------------------------------------------------
//    Devuelve una cadena después de eliminar los espacios por la derecha
//-----
function rTrim(cCadena) {
	var re = /(\s+)$/g;
	
	return cCadena.replace(re,"");
}

// ----------------------------------------------------------
//    Devuelve una cadena después de eliminar los espacios por la izquierda y derecha
//-----
function trim(cCadena) {
	var re = /^(\s+)|(\s+)$/g;
	
	return cCadena.replace(re,"");
}