<!--
function esNombre(str)
  {
  var pattern= new RegExp("^[-a-zA-ZÁÉÍÓÚáéíóúüÜñÑ\.\' ]*$");
  return str.match(pattern);
  }

function esVacio(value)
  {
  var pattern = /^(\s*)$/;
  return value.match(pattern);
  }

function esNumero(str)
  {
  var pattern= new RegExp("^[0-9]+$");
  return str.match(pattern);
  }

function esPrecio(str)
  {
  var pattern= new RegExp("^[0-9]{1,7}(\.[0-9]{0,2})?$");
  return str.match(pattern);
  }

function esNombreConNumeros(str)
  {
  var pattern= new RegExp("^[-a-zA-Z0-9ÁÉÍÓÚáéíóúüÜñÑ\.\' ]*$");
  return str.match(pattern);
  }

function esNumeroDecimal(str)
{var partes=new Array();
 var separador=".";

 partes=str.split(separador);
 if(partes.length!=2)
  return(false);
 if((!partes[0].length)||(!partes[1].length))
  return(false);
 if((!esNumero(partes[0]))||(!esNumero(partes[1])))
  return(false);
 return(true);
}

function esHora(hora)
  {
  var ExpresionRegular_patron = "^([0-9]{1,2})\:([0-9]{1,2})$";
  var ExpresionRegular = new RegExp(ExpresionRegular_patron);
  if(ExpresionRegular.test(hora))
    {
    arreglo = ExpresionRegular.exec(hora);
    if(arreglo[1] < 24 && arreglo[2] < 60)
      return(true);
    }
  return(false);
  }

function esHora2(hora,minu)
  {
  if(esNumero(hora) && esNumero(minu))
    {
    if(hora >= 0 && hora < 24 && minu >=0 && minu < 60)
      return(true);
    }
  return(false);
  }

function esFechaValida(dia,mes,ano)
  {
  var dias = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
  if(dia <= dias[mes - 1])
    {
    return(true);
    }
  var bisiesto = (((ano%4 == 0) & (ano%100 != 0)) | (ano%400 == 0))?true:false;
  if(bisiesto & mes == 2 & dia == 29)
    {
    return(true);
    }
  return(false);
  }

function esDigitoValido(rut,dv)
  {
  var valor = dv.toLowerCase();
  if(DigitoVerificadorRut(rut) == valor)
    {
    return(true);
    }
  return( false );
  }

function DigitoVerificadorRut(rut)
  {
  var s = 0;
  var l_dv = "";
  var i=0;
  for (i=2; i< 8; i++){
    s = s + ( rut % 10 ) * i;
    rut = (rut - ( rut % 10 )) / 10;
  }
  s = s + ( rut % 10 ) * 2;
  rut = (rut - ( rut % 10 )) / 10;
  s = s + ( rut % 10 ) * 3;
  rut = (rut - ( rut % 10 )) / 10;
  s = 11 - ( s % 11 );
  if ( s == 10 )
     l_dv = "k";
  else
     if ( s == 11 )
        l_dv = "0"
     else
        l_dv = s + "";   // Se convierte el numero s a string
  return( l_dv );
  }

function esNumeroTelefono(fono)
  {
  var ExpresionRegular_patron = "^([0-9]{1,2}-){0,1}([0-9]{6,8})$";
  var ExpresionRegular = new RegExp(ExpresionRegular_patron);
  if(!ExpresionRegular.test(fono))
    {
    // revisar si es teléfono 800 o 600
    var ExpresionRegular_patron = "^(600|800)([0-9]{7})$";
    var ExpresionRegular = new RegExp(ExpresionRegular_patron);
    return(ExpresionRegular.test(fono));
    }
  else
    return(true);
  }
function esNumeroCelular(fono)
  {
  var ExpresionRegular_patron = "^([0-9]{1,2}-){0,1}([0-9]{8,8})$";
  var ExpresionRegular = new RegExp(ExpresionRegular_patron);
  if(!ExpresionRegular.test(fono))
    {
    // revisar si es teléfono 800 o 600
    var ExpresionRegular_patron = "^(600|800)([0-9]{7})$";
    var ExpresionRegular = new RegExp(ExpresionRegular_patron);
    return(ExpresionRegular.test(fono));
    }
  else
    return(true);
  }

function esEMail(email)
  {  
  //Strings de expresiones regulares: username y hostname
  var ExpresionRegular1_Str = "(@.*@)|(\\.\\.)|(@\\.)|(\\.@)|(^\\.)";
  var ExpresionRegular2_Str = "^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$"; 
  //Objetos expresiones regulares
  var ExpresionRegular1 = new RegExp( ExpresionRegular1_Str );
  var ExpresionRegular2 = new RegExp( ExpresionRegular2_Str );

  //Retorna
  /*if (email.type == "select-one") {
        return( !ExpresionRegular1.test( email.options[email.selectedIndex].text )  &&
             ExpresionRegular2.test( email.options[email.selectedIndex].text ) );
    }
  else if (email.type == "select-multiple") {
     return( !ExpresionRegular1.test( email.options[email.selectedIndex].text )  &&
                  ExpresionRegular2.test( email.options[email.selectedIndex].text ) );
    }
  else*/
    return( !ExpresionRegular1.test(email) && ExpresionRegular2.test(email));
  }

function emailCheck (emailStr) {

/* 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.  1 means check it, 0 means don't. */

var checkTLD=1;

/* The following is the 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)$/;

/* The following pattern is 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=/^(.+)@(.+)$/;

/* The following string represents the pattern for matching all special
characters.  We don't want to allow special characters in the address. 
These characters include ( ) < > @ , ; : \ " . [ ] */

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 +")*$");

/* 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 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("La dirección de email está incorrecta (revise los @ y los .'s)");
return false;
}
var user=matchArray[1];
var domain=matchArray[2];

// Start by checking that only basic ASCII characters are in the strings (0-127).

for (i=0; i<user.length; i++) {
if (user.charCodeAt(i)>127) {
alert("El nombre de usuario en el email contiene caracteres invalidos");
return false;
}
}

for (i=0; i<domain.length; i++) {
if (domain.charCodeAt(i)>127) {
alert("El nombre de dominio en el email contiene caracteres invalidos");
return false;
 }
}

// See if "user" is valid 

if (user.match(userPat)==null) {

 // user is not valid

 alert("El nombre de usuario  en el email no es valido");
 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("IP de destino en el email invalido");
  return false;
 }
 }
 return true;
}

// 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) {
     alert("El nombre de dominio en el email no es valido");
     return false;
    }
  }

 /* 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 country (uk, nl), and that there's a hostname preceding 
    the domain or country. */

 if (checkTLD && domArr[domArr.length-1].length!=2 && 
     domArr[domArr.length-1].search(knownDomsPat)==-1) {
     alert("La dirección de email debe terminar en 2 letras o en un"+
           " dominio conocido");
     return false;
 }

 // Make sure there's a host name preceding the domain.

  if (len<2) {
   alert("A la dirección de email le falta el hostname");
   return false;
  }

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

function validarRangoFechas(d_a,d_m,d_d,h_a,h_m,h_d)
{
 var fechai=new Date(d_a,d_m-1,d_d,12,0,0);

 var fechaf=new Date(h_a,h_m-1,h_d,12,0,0);
 
 if(fechai.getDate()!=d_d*1)
  {alert("Fecha de inicio inválida");
   return(false);
  }

 if(fechaf.getDate()!=h_d*1)
  {alert("Fecha de fin inválida");
   return(false);
  }

 if(Date.parse(fechaf.toString())<Date.parse(fechai.toString()))
  {alert("La fecha de fin debe ser mayor que la de inicio");
   return(false);
  }
 return(true);
}
function validarFechaRepeticion(d_a,d_m,d_d,h_a,h_m,h_d)
{
 var fechai=new Date(d_a,d_m-1,d_d,12,0,0);

 var fechaf=new Date(h_a,h_m-1,h_d,12,0,0);
 
 if(fechai.getDate()!=d_d*1)
  {alert("Fecha de Repeticion inválida");
   return(false);
  }

 if(fechaf.getDate()!=h_d*1)
  {alert("Fecha de fin inválida");
   return(false);
  }

 if(Date.parse(fechaf.toString())<Date.parse(fechai.toString()))
  {alert("La Fecha de Repeticion debe mayor que la Fecha de Reserva");
   return(false);
  }
 return(true);
}
//-->