STRPLIC  = "\\" + String.fromCharCode([92]) + "'";
STRASPAS = String.fromCharCode([92]) + String.fromCharCode([34]);

/**
 *    Identifica e mostra na janela atual um dado informado em uma Location
 */
function pegaDado(pesquisa) {
	document.write(pegaDadoSemWrite(pesquisa));
}

/**
 *    Identifica um dado informado em uma Location
 */
function pegaDadoSemWrite(pesquisa, pbTemQueAchar, pbRetChv) {
   return Global_obtemParametro(
         unescape(window.location.search).substring(1)
      ,  pesquisa, "&"
      ,  pbTemQueAchar, pbRetChv
   );
}

/**
 *    Retorna o conteúdo de uma String
 *
 * Parâmetros
 *    - psDados
 *       Dados a serem analisados
 *
 *    - psChave
 *       Chave a ser identificada
 *
 *    - pSepDados
 *       Separador dos dados
 *
 *    - pbTemQueAchar
 *       Define se a inexistência do parâmetro deve retornar "undefined"
 *
 *    - pbRetChv
 *       Define se o símbolo que separa a chave dos dados devem ou não ser retornados
 *
 */
function Global_obtemParametro(
   psDados, psChave, psSepDados
,  pbTemQueAchar, pbRetChv
)   {
   
   // inicializa variáveis
   var dado   = psDados;
	var pos    = psDados.indexOf(psChave);
	var posFin = psDados.indexOf(psSepDados, pos);
	
	// verifica se o separador da chave dos dados (símbolo de igual) deve ser retornado
	pbRetChv = (String(pbRetChv) != "false");
   
   // verifica se foi encontrada a chave e esta deve existir
   if (pos < 0 && pbTemQueAchar == true)   {
      return 'undefined';
   }
   
   // verifica o retorno
	if (posFin == -1) {
		dado = dado.slice(pos+psChave.length + (pbRetChv?0:1));
	}  
	else {
		dado = dado.slice(pos+psChave.length + (pbRetChv?0:1), posFin + (pbRetChv?0:-1));
	}
	
	// return
	return dado;
	
}

/**
 *    Obtem um parâmetro informado da janela top.dados, escrevendo-a
 */
function pegaDadoOnDados(pesquisa) {
	document.write(pegaDadoSemWriteOnDados(pesquisa));
}

/**
 *    Obtem um parâmetro informado da janela top.dados
 */
function pegaDadoSemWriteOnDados(pesquisa) {
   return pegaDadoDaJanelaSemEscrever(pesquisa, top.dados.location);
}

/**
 *    Obtem um parâmetro informado a uma janela, escrevendo-a
 */
function pegaDadoDaJanela(pesquisa, pLocal) {
	document.write(pegaDadoDaJanelaSemEscrever(pesquisa, pLocal));
}

/**
 *    Obtem um parâmetro informado a uma janela
 */
function pegaDadoDaJanelaSemEscrever(pesquisa, pLocal) {
   // identifica os dados
	var dado = unescape(pLocal.search).substring(1);
	var pos = dado.indexOf(pesquisa);
	var posFin = dado.indexOf("&", pos);
	if (posFin == -1) {
		dado = dado.slice(pos+pesquisa.length);
	}  
	else {
		dado = dado.slice(pos+pesquisa.length, posFin);
	}
	return dado;
}

/**
 *    Obtem o nome do mes, dado seu numero
 *    Um controle é feito para retirar caracteres especiais
 *    (de março), pois é usado em \global\arquivos
 */
function nomeMes(mes, pbRetFormat)	{

   pbRetFormat = String(pbRetFormat) != "false";
   var sRet = "";
   
   switch (mes)	{
	case 1:
   case '01':
		sRet = "Janeiro";
		break;
	case 2:
   case '02':
		sRet = "Fevereiro";
		break;
	case 3:
   case '03':
		sRet = "Março";
		break;
	case 4:
   case '04':
		sRet = "Abril";
		break;
	case 5:
   case '05':
		sRet = "Maio";
		break;
	case 6:
   case '06':
		sRet = "Junho";
		break;
	case 7:
   case '07':
		sRet = "Julho";
		break;
	case 8:
   case '08':
		sRet = "Agosto";
		break;
	case 9:
   case '09':
		sRet = "Setembro";
		break;
	case 10:
   case '10':
		sRet = "Outubro";
		break;
	case 11:
   case '11':
		sRet = "Novembro";
		break;
	case 12:
   case '12':
		sRet = "Dezembro";
		break;
	}
	
	// retira o caracter especial de 'março'	
	if (!pbRetFormat) {
	   sRet = sRet.toLowerCase().replace(/ç/,"c");
	}
	
	return sRet;
}

// sem o caracter especial 'ç'
function getCodigoMes(mes)	{
   
   switch (mes.toLowerCase())	{
	case "janeiro":
		return 1;
		break;
	case "fevereiro":
		return 2;
		break;
	case "marco":
		return 3;
		break;
	case "abril":
		return 4;
		break;
	case "maio":
		return 5;
		break;
	case "junho":
		return 6;
		break;
	case "julho":
		return 7;
		break;
	case "agosto":
		return 8;
		break;
	case "setembro":
		return 9;
		break;
	case "outubro":
		return 10;
		break;
	case "novembro":
		return 11;
		break;
	case "dezembro":
		return 12;
		break;
	}
	return 0;
}


// Função que converte uma data dd/mm/yy 
// ou yyyymmdd para o formato "dd de Mes de yyyy"
function convertDataExtenso(dataProc)	{
	
   if (dataProc.indexOf("/") > -1)  {
	   var dia = dataProc.substring(0,dataProc.indexOf("/"));
	   var mes = nomeMes(dataProc.substring(dataProc.indexOf("/")+1,dataProc.lastIndexOf("/")));
	   var ano = dataProc.substring(dataProc.lastIndexOf("/")+1, dataProc.length);
   }
   else  {
	   var ano = dataProc.substring(0,4);
	   var mes = nomeMes(dataProc.substring(4,6));
	   var dia = dataProc.substring(6, dataProc.length);

   }

	if (ano < 1999)
		ano = 1900 + ano;
	
	var saida = dia + " de " + mes + " de " +  ano;
	
	return  saida;
}

/**
 *    Retorna uma data formatada como dd/mm/yyyy a apartir de uma entrada ddmmyyyy
 */
function Global_formataData(pData)   {
   
   // inicializa o retorno
   ret_Global_formataData = "";
   
   // verifica os parâmetros informados
   if (String(pData) != "null")  {
      
      // verifica se a data está formatada
      dataAux = String(pData);
      if (dataAux.indexOf("/") > -1)  {
   	   var dia = dataAux.substring(0,dataAux.indexOf("/"));
   	   var mes = dataAux.substring(dataAux.indexOf("/")+1,dataAux.lastIndexOf("/"));
   	   var ano = dataAux.substring(dataAux.lastIndexOf("/")+1, dataAux.length);

         // prepara o retorno
         ret_Global_formataData = 
               strZero(dia, 2)
            +  "/" + strZero(mes, 2)
            +  "/" + strZero(ano, 4)
         ;
         
      }  else  {
      
         // garante que a data tem pelo menos 10 caracteres
         dataAux += "00000000";
         
         // prepara o retorno
         ret_Global_formataData = 
               dataAux.substring(0, 2)
            +  "/" + dataAux.substring(2, 4)
            +  "/" + dataAux.substring(4, 8)
         ;
         
      }
      
   }
   
   // retorna
   return ret_Global_formataData;
}

/**
 *    Função que retorna um valor formatado a partir de um numero
 *    Considera ',' como separador de decimal e decimais corretas
 *    no parametro de entrada
 *    Melhor usar Global_formataNumero (abaixo)
 */
function formataValor(valor, piQtdDecimais, pbCritica)  {

   // inicializa a variável auxiliar
   var aux  = "";
   var qtdDec = 0;

   // verifica o número de decimais informados
   if (     String(piQtdDecimais) == "undefined"
         || isNaN(piQtdDecimais)
         ) {     
      piQtdDecimais = 2;
   }
   
   iDec = String(valor).indexOf(",");
   if (iDec > -1)  {
      iDec = String(valor).length - String(valor).indexOf(",") + 1;
      if (iDec < piQtdDecimais) {
         valor += strZero("", piQtdDecimais-iDec);
      }
   }
   
   
   // remove símbolos
   valor = String(valor).replace(/\./g, "").replace(/\,/g, "").replace(/\ /,"");
   if (!isNaN(valor)) {
      valor = parseInt(String(valor));
   }
   
   // valida o valor informado
   if (isNaN(valor)) {
      if (     String(pbCritica) != "undefined"
            && pbCritica
            )  {
         alert("O valor informado é inválido");
         valor = 0;
      }
      else  {
         valor = 0;
      }
   }

   // prepara o valor informado
   div = 1;
   for(iQtdDecimais=piQtdDecimais; iQtdDecimais > 0; iQtdDecimais--)
      div *= 10;
   valor /= div;
   aux += valor;

   // Inclui a virgula dos centavos
   if (aux.indexOf(".") > -1)   {
      cent = aux.substring(aux.indexOf(".")+1,aux.length);
      aux = aux.substring(0,aux.indexOf("."));
   }
   else  {
      cent = "";
      for(iQtdDecimais=piQtdDecimais; iQtdDecimais > 0; iQtdDecimais--)
         cent += "0";
   }

   // Inclui os pontos de milhar
   fim = 3;
   ini = aux.length;
   if (fim > aux.length-1) {
      aux2 = aux;
   }
   else  {
      aux2 = "";
      while (fim <= aux.length-1)   {
         ini = ini - 3;
         aux2 = aux.substr(ini,3) + aux2;
         if (aux.substring(0,ini) != "-") {
            aux2 = "." + aux2;
         }
         fim = fim + 3;
      }
      aux2 = aux.substring(0,ini) + aux2;
   }

   // adiciona o texto dos centavos
   if (cent != "")   {
      aux2 = aux2 + "," + cent;
   }

   // verifica se o retorno inicia-se com ","
   if (aux2.substring(0, 1) == ",") {
      aux2 = "0" + aux2;
   }
   
   // retorna
   return aux2;
}


/**
 *    Função que realiza a formatação de um número
 *    Considera ',' como separador de decimal
 */
function Global_formataNumero(numero, piQtdDecimais)  {

   // verifica o número informado retirando o separador de milhar e espaços
   ret_Global_formataNumero = String(numero).replace(/\./g, "").replace(/\ /,"");

   // verifica o número de decimais informados
   if (     String(piQtdDecimais) == "undefined"
         || isNaN(piQtdDecimais)
         ) {     
      piQtdDecimais = 2;
   }

   // identifica a posição, as decimais e a qtd informadas
   iPosDecimais = ret_Global_formataNumero.indexOf(",");
   if (iPosDecimais > -1)   {
      iQtdDecimais = ret_Global_formataNumero.length - iPosDecimais - 1;
      sDecimais    = ret_Global_formataNumero.substring(iPosDecimais + 1);
   }
   else  {
      iQtdDecimais = (ret_Global_formataNumero.length >= piQtdDecimais ? piQtdDecimais : ret_Global_formataNumero.length - piQtdDecimais);
      sDecimais    = ret_Global_formataNumero.substring(ret_Global_formataNumero.length - piQtdDecimais);
   }
   
   // retira do número a vírgula identificando um valor válido
   ret_Global_formataNumero = String(parseInt(ret_Global_formataNumero.replace(/\,/g, "")));
   if (isNaN(parseInt(ret_Global_formataNumero)))   {
      ret_Global_formataNumero = "0";
   }

   // adiciona zeros as decimais
   for(iK=iQtdDecimais; iK < piQtdDecimais; iK++)  {
      sDecimais += "0";
   }
   
   // identifica a parte inteira
   sInteiros = "";
   if (  iPosDecimais > -1
      || ret_Global_formataNumero.length >= piQtdDecimais
      ) {
      sInteiros = ret_Global_formataNumero.substring(0, (ret_Global_formataNumero.length - iQtdDecimais));
   }
   
   // Inclui os pontos de milhar
   fim = 3;
   ini = sInteiros.length;
   if (fim > sInteiros.length-1) {
      aux2 = sInteiros;
   }
   else  {
      aux2 = "";
      while (fim <= sInteiros.length-1)   {
         ini = ini - 3;
         aux2 = sInteiros.substr(ini,3) + aux2;
         if (sInteiros.substring(0,ini) != "-") {
            aux2 = "." + aux2;
         }
         fim = fim + 3;
      }
      aux2 = sInteiros.substring(0,ini) + aux2;
   }
   sInteiros = aux2;

   // formata o retorno
   ret_Global_formataNumero = 
         ""
      +  sInteiros
      +  ","
      +  sDecimais.substring(0, piQtdDecimais)
   ;
   
   // garante um zero na frente
   if (ret_Global_formataNumero.substring(0,1) == ',')   {
      ret_Global_formataNumero = "0" + ret_Global_formataNumero;
   }

   // retorna
   return ret_Global_formataNumero;

}

/**
 *    Função que faz rolar o scroll da tela na posição desejada, facilitando 
 *    a visualização do resultado.
 *    Alem do nome do elemento, é preciso informar de qual elemento será 
 *    contabilizado o deslocamento desejado: do proprio elemento
 *    ('self') ou do seu pai ('parent')
 */
function scrollToCursor(sNomeElement, sOffset) {      
   
   if (String(sOffset) == 'self') {
      iMax = ((String(document.getElementById(sNomeElement)) != "undefined")
               ? document.getElementById(sNomeElement).offsetTop / 3
               : 200
      );
   }

   if (String(sOffset) == 'parent') {
      
      iMax = ((String(document.getElementById(sNomeElement)) != "undefined")
               ? document.getElementById(sNomeElement).offsetParent.offsetTop / 3
               : 200
      );      
   }

   for (i=0; i< iMax;i++)   {
      setTimeout("self.scrollBy(0,3)", 300);
   }
}


/**
 *    Função que retorna uma string de comprimento iCasas, 
 *    alinhada com sChar à esquerda.
 *    Flag decide se trunca ou não o resultado em iCasas.
 */
function strZero(sValor, iCasas, sChar, bTrunca) {

   // garante que valor é uma String
   sValor = String(sValor);
   
   // verifica o caracter informado
   if (String(sChar) == "undefined")   {
      sChar = "0";
   }
   
   // processa cada caracter de sValor
   var sRet = "";
   for(var i=sValor.length; i<iCasas; i++, sRet+=sChar);
   sRet += sValor;

   if (bTrunca && (sRet.length > iCasas)) {
      sRet = sRet.substring(
         sRet.length - iCasas,
         sRet.length
      );
   }
   return sRet;
}
   
// Função para evitar ler páginas em cache
function reloadDadosOnceOnly() {
	 if (!top.reloaded_dados) {
   		top.reloaded_dados = true;
        	//window.dados.history.go(0);
		window.dados.location.reload(true);
	 }
	 else
		top.reloaded_dados = false;

}


// Função para evitar que back em páginas de arqentrada 
// vá para página post (somente no IE e se vier da transferência)
function testRetornaFromArqEnt111(when) {
	 if ((navigator.appName.indexOf('Microsoft') > -1) && varImgSelected.indexOf('marquivosSelected') > -1) {
		if (when == 0)
			top.retornaQuantos = -2;
		else if (when == 1)
			top.retornaQuantos = -1;
	 }
}


// Função que evita mais de 1 clique num botão de formulário.
// Assim, o servlet não dá erro.
function resetClique()	{
	top.countClique = 0;
}

function testaClique()	{
	top.countClique++;
	
	if (top.countClique != 1) {
		alert("Favor aguardar o processamento da última consulta.");
		return false;
	}
	else
		return true;		
}

function getNomeArquivo(nomeArq)	{
	ret = "";
	for(k=nomeArq.length; k > -1; k--)	{
		if (nomeArq.substr(k, 1) == '/')	break;
		ret = nomeArq.substr(k, 1) + ret;
	}
	return ret;
}


/**
 *    Realiza escape para a preparação de um uma referência com #
 * para uma string válida
 */
function obtemStringRef(psRef)   {
   tralha = escape("#");
   return psRef.replace(/#/g, tralha);
}

/**
 *    Identifica a posição de um objeto dentro da coleção de elementos
 *    de um formulário. Se existir mais de um elemento com o mesmo nome,
 *    a função concatena com psSepElem (default ',') os índices encontrados.
 */
function obtemIndiceElemento(vform, psNomeElemento, psSepElem, pbMaisDeUm) {

   // variáveis
   sRetorno     = "";
   sFim         = "";
   bJaEncontrou = false;

   // valida parâmetros informados
   if (String(psSepElem) == "undefined")  {
      psSepElem = ",";
   }
   if (String(pbMaisDeUm) == "undefined")  {
      pbMaisDeUm = false;
   }

   // procura o elemento no formulário informado
   for(k=0; k < vform.elements.length; k++)  {
      if (vform.elements[k].name == psNomeElemento)   {
      
         if (bJaEncontrou) {
            sRetorno += psSepElem;
         }
         
         sRetorno += k;
         bJaEncontrou = true;
                     
         // termina a busca se não deve retornar multiplos
         if (!pbMaisDeUm) {
            break;
         }
         
      }
      
   }
      
   // trata a exceção
   if (sRetorno.length < 1) {
      sRetorno = "-1";
   }

   // retorna
   return sRetorno;
}


/**
 *    Abre uma janela de alerta
 */
function abreAlerta(psTexto)	{
  contents="<html><head><title>Atenção:</title></head>"; 
  contents+="<body bgcolor=#C3C3C3>"; 
  contents+="<center><h3>" + psTexto + "<br>";
  contents+="Por favor, aguarde...</h3></center></body></html>";  
  
  //  abre a janela
  alerta=window.open('','alerta', 'toolbar=no,noresize,menubar=no,width=300,height=90,left=260,top=260');
  
  //  escreve o conteúdo
  alerta.document.writeln(contents);
  
  //  armazena no topo a referência para a janela aberta
  top.janela = alerta;
  
  //  retorna
  return true;
}


/**
 *    Quebra uma String com um Separador, adicionando a cada String separada
 * uma String
 *
 * Parâmetros
 *    - pString
 *          String a ser separada
 *
 *    - psSep
 *          String separadora a ser considerada
 *
 *    - psStringAdd
 *          String a ser adicionada
 *
 *    - pJanelaMostrarProcessamento
 *          Janela a ser utilizada na visualização do processamento de dados
 *
 */
function splitString(
               pString, psSep, psStringAdd
            ,  pJanelaMostrarProcessamento
            )  {
   
   // variável auxiliar
   sStringAdd = "_XXXsplitString_sStringAdd_XXX_";
   
   // verifica se pString é uma String 
   if (String(pString.replace) != "undefined")  {

      // mostra o processamento
      escreveNaJanela(
            pJanelaMostrarProcessamento
         ,     "<br>"
            +  "Separador Informado: --->>" + psSep + "<<---"
            +  "<br>"
            +  "Separador de Adição: --->>" + psStringAdd + "<<---"
            +  "<br>"
            +  "String Informada: --->>" + pString + "<<---"
      );

      // identifica a string a ser tratada
      if (pString.search(psSep) > -1)  {
         
         // verifica se as strings são iguais adicionando o separador no início
         if (psSep == psStringAdd && psSep == pString)  {
            pString += sStringAdd;
         }
            
         // adiciona ao separador a string a participar do array
         pString = pString.replace(
               new RegExp(psSep, "g")
            ,  psSep + sStringAdd + psSep
         );
         
      }
      
      // mostra o processamento
      escreveNaJanela(
            pJanelaMostrarProcessamento
         ,     "<br>"
            +  "String Modificada: --->>" + pString + "<<---"
      );

      // prepara o array a ser retornado
      asRet_01 = pString.split(psSep);
      
      // mostra o processamento
      escreveNaJanela(
            pJanelaMostrarProcessamento
         ,     "<br>"
            +  "Elementos(" + asRet_01.length + ") : --->>" + asRet_01 + "<<---"
      );

      // substitui cada String 'sStringAdd' pela String de adição
      for(iPos_01=0; iPos_01 < asRet_01.length; iPos_01++)  {
         asRet_01[iPos_01] = asRet_01[iPos_01].replace(
               new RegExp(sStringAdd, "g")
            ,  psStringAdd
         );
      }
      
      // mostra o processamento
      escreveNaJanela(
            pJanelaMostrarProcessamento
         ,     "<br>"
            +  "Retorna: --->>" + asRet_01 + "<<---"
            +  "<br>"
      );

      // retorna
      return asRet_01;
      
   }
   
   // prepara o array de retorno
   this.asRet = new Array();

   // processa como um array
   this.asString = pString;
   for(
         this.iPos=0
      ;  this.iPos < this.asString.length
      ;  this.iPos++
      )   {
         
      // mostra o processamento
      escreveNaJanela(
            pJanelaMostrarProcessamento
         ,     "<br>******> this.iPos=" 
            +  this.iPos + "(" + pString + "): '" 
            +  this.asString[this.iPos] + "'"
      );

      // identifica o array de retorno
      asAux = new splitString(
            this.asString[this.iPos], psSep, psStringAdd
         ,  pJanelaMostrarProcessamento
      );
      
      // adiciona o array auxiliar ao retorno
      for(iasAux = 0; iasAux < asAux.length; iasAux++)   {
         if (asAux[iasAux] != "")   {
            this.asRet[this.asRet.length] = asAux[iasAux];
         }
      }
      
   }

   // mostra o processamento
   escreveNaJanela(
         pJanelaMostrarProcessamento
      ,     "<br>"
         +  "Elementos(" + asRet_01.length + ") : --->>" + asRet_01 + "<<---"
         +  "<br>"
         +  "Retorna: --->>" + this.asRet + "<<---"
         +  "<br>"
   );

   // retorna
   return this.asRet;
   
}

/**
 *    Dado um objeto que representa uma janela ou o nome da janela, retorna
 * o objeto janela respectivo ou "undefined" se ela não for uma janela válida
 */
function identificaJanela(pWindow)  {
   
   // inicializa o retorno
   identificaJanela_ret = "undefined";
   
   // valida o parâmetro informado
   if (     String(pWindow) != "undefined"
         && String(pWindow) != "null"
      ) {

      if (     String(pWindow.document) == "undefined"
            && (
                  String(pWindow.name)                 != "undefined"
               || String(typeof pWindow).toLowerCase() == "string"
            )
         ) {
         pWindow = eval(pWindow);
      }

      if (     String(pWindow)          != "undefined"
            && String(pWindow)          != "null"
            && String(pWindow.document) != "undefined"
         ) {
         identificaJanela_ret = pWindow;
      }

   }
   
   // retorna
   return identificaJanela_ret;
   
}

/**
 *    Escreve em uma janela de dados informada se ela for válida
 */
function escreveNaJanela(pWindow, psMsg)  {
   pWindow = identificaJanela(pWindow);
   if (String(pWindow) != "undefined") {
      pWindow.document.write(psMsg);
   }
}

/**
 *    Limpa os dados de uma janela
 */
function limpaJanela(pWindow)  {
   pWindow = identificaJanela(pWindow);
   if (String(pWindow) != "undefined") {
      pWindow.document.close();
      pWindow.document.open();
   }
}


/**
 *  Retorna a String removendo um determinado caracter à esquerda
 */
function lTrimChar(pVlr, pChar)  {
   
   // inicializa variáveis
   bPassouZero    = false;
   sVlr           = String(pVlr);
   sRet_lTrimChar = "";
   sChar          = String(pChar);
   
   // precorre cada caracter
   for(  i_lTrimZeros=0
      ;  i_lTrimZeros < sVlr.length
      ;  i_lTrimZeros++
      )   {
         
      // adiciona o pedaço
      if (sVlr.substring(i_lTrimZeros, i_lTrimZeros+1) != sChar || bPassouZero)  {
         sRet_lTrimChar += sVlr.substring(i_lTrimZeros, i_lTrimZeros+1);

         // verifica se passou do zero
         if (!bPassouZero && sVlr.substring(i_lTrimZeros, i_lTrimZeros+1) != sChar) {
            bPassouZero = true;
         }
               
      }
      
   }
   
   // retorna
   return sRet_lTrimChar;
}


/**
 *  Retorna a String de um numero removendo espaços à esquerda
 */
function lTrim(pVlr)  {
   return lTrimChar(pVlr, " ");
}


/**
 *  Retorna a String de um numero removendo zeros à esquerda
 */
function lTrimZeros(pVlr)  {
   return lTrimChar(lTrimChar(pVlr, " "), "0");
}


/**
 *    Dado uam variável retorna o respectivo valor numérico
 */
function Global_obtemValorNumerico(pVlr_obtemValorNumerico) {
   
   // valida o valor de retorno
   if (     String(pVlr_obtemValorNumerico) != "undefined"
         && String(pVlr_obtemValorNumerico) != ""
         && (!isNaN(pVlr_obtemValorNumerico) || !isNaN(parseInt(String(pVlr_obtemValorNumerico))))
      )  {
      ret_obtemValorNumerico = lTrimZeros(pVlr_obtemValorNumerico);
      if (ret_obtemValorNumerico == "") 
         ret_obtemValorNumerico = 0;
      else
         ret_obtemValorNumerico = parseInt(ret_obtemValorNumerico);
   }
   else  {
      ret_obtemValorNumerico = 0;
   }
   
   // retorna
   return ret_obtemValorNumerico;
   
}


/**
 *    Valida o conteúdo de um objeto, retornando o próprio objeto informado, null ou
 * um outro objeto informado em substituição.
 *
 * Funcionamento:
 *    Esta rotina recebe um objeto de dados a ser validado e um agrupamento de objetos 
 * (ObjAgrupamento) que contém uma relação de dados inválidos. Cada dados desta relação
 * pode conter uma informação que deve ser utilizada em substituição ao conteúdo do objeto
 * quando a informação contida no objeto for igual ao elemento da lista. Se o elemento da lista
 * não tiver um outro objeto a ser utilizado em substituição será retornado null
 *
 * Parâmetros
 *    - pObj_validaConteudoObjeto
 *       Objeto a ser utilizado na validação
 *
 *    - pAgrup_validaConteudoObjeto
 *       Agrupamento de dados que contém a relação das informações que não são válidas
 * e valores que devem ser utilizados em substituição
 *
 */
function Global_validaConteudoObjeto(
                  pObj_validaConteudoObjeto
               ,  pAgrup_validaConteudoObjeto
               )  {

   // verifica os parâmetros informados
   if (     pObj_validaConteudoObjeto
         && pAgrup_validaConteudoObjeto
         && String(pAgrup_validaConteudoObjeto.obtemTotalObjetos) != "undefined"
      )  {
         
      // procura uma chave de objeto do agrupamento que seja igual ao objeto informado
      for(
            i_validaConteudoObjeto = 0
         ;  i_validaConteudoObjeto < pAgrup_validaConteudoObjeto.obtemTotalObjetos()
         ;  i_validaConteudoObjeto++
         )  {

         // identifica a chave do objeto
         chv_validaConteudoObjeto = pAgrup_validaConteudoObjeto.obtemChaveObjeto(i_validaConteudoObjeto);
         
         // identifica o objeto
         obj_validaConteudoObjeto = pAgrup_validaConteudoObjeto.obtemObjetoPorIndice(i_validaConteudoObjeto);

         // verifica se a chave é igual ao objeto informado
         if (chv_validaConteudoObjeto && chv_validaConteudoObjeto == pObj_validaConteudoObjeto)   {
            
            // retorna o objeto a ser utilizado em substituição
            if (obj_validaConteudoObjeto)   {
               return obj_validaConteudoObjeto;
            }
            
            // retorna null
            else  {
               return null;
            }
            
         }
         
      }
      
   }
   
   // retorna o próprio objeto informado
   return pObj_validaConteudoObjeto;
   
}



/**
 *    Retorna se um objeto é válido
 */
function Global_objetoEValido(pObjeto) {
   ret_objetoEValido = String(pObjeto) != "undefined" && String(pObjeto) != "null";
   return ret_objetoEValido;
}