function verifUserComent(name, email, site, comments) {

  // toate campurile sunt obligatorii
  if (name.trim().length == 0 || email.trim().length == 0 || comments.trim().length == 0) {
    window.alert("Va rugam sa completati numele, adresa de email si comentariile !");
    return false;
  }
  // emailul sa fie valid
  if (!emailCheck(email)) {
    window.alert("Adresa de email nu e scrisa corecta !");
    return false;
  }
  return true;
}

function removeSpace(s) {
  var length = s.length;
  var spaceless = new String("");
  var r = 0;
  while (r < length) {
    if (s[r] != ' ') {
      spaceless += s[r];
    }
    r++;
  }
  return spaceless;
}

/*
 * Changes:  Sandeep V. Tamhankar (stamhankar@hotmail.com) 
 * 1.1.2: Fixed a bug where trailing . in e-mail address was passing (the bug is
 * actually in the weak regexp engine of the browser; I simplified the regexps
 * to make it work). 1.1.1: Removed restriction that countries must be preceded
 * by a domain, so abc@host.uk is now legal. However, there's still the
 * restriction that an address must end in a two or three letter word. 1.1:
 * Rewrote most of the function to conform more closely to RFC 822. 1.0:
 * Original
 */

function emailCheck(emailStr) {
  /*
   * 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("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
  }

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

function loadXMLDoc(fname) {
  var xmlDoc;
  // code for IE
  if (window.ActiveXObject) {
    xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
  }
  // code for Mozilla, Firefox, Opera, etc.
  else if (document.implementation && document.implementation.createDocument) {
    xmlDoc = document.implementation.createDocument("", "", null);
  } else {
    alert('Your browser cannot handle this script');
  }
  xmlDoc.async = false;
  xmlDoc.load(fname);
  return (xmlDoc);
}

/*
 * Folosita in listele de la Info Util, in articole si albumele foto pentriu afisarea comentariilor.
 */
function afiseazaComentarii(fisierXMLComentarii) {
  var divLista = document.getElementById('divListaComent');
  divLista.style.visibility = "visible";
  //document.getElementById('divComentRasp').style.visibility = "visible";

  if (divLista.innerHTML == "") {
    xml = loadXMLDoc(fisierXMLComentarii);

    xsl = loadXMLDoc("/xslget/lista-comentarii.xsl");

    if (window.ActiveXObject) {
      var ex = xml.transformNode(xsl);
      divLista.innerHTML = ex;

    } else if (document.implementation && document.implementation.createDocument) {
      xsltProcessor = new XSLTProcessor();
      xsltProcessor.importStylesheet(xsl);
      resultDocument = xsltProcessor.transformToFragment(xml, document);
      divLista.appendChild(resultDocument);
    }
  }
}