Example #1
0
void wxExStyle::SetNo(const wxString& no, const wxString& macro)
{
  m_No.clear();
  
  wxStringTokenizer no_fields(no, ",");

  // Collect each single no in the vector.
  while (no_fields.HasMoreTokens())
  {
    const wxString single = 
      wxExLexers::Get()->ApplyMacro(no_fields.GetNextToken(), macro);
      
    bool error = true;

    if (single.IsNumber())
    {
      const int style_no = atoi(single.c_str());
      
      if (style_no >= 0 && style_no <= wxSTC_STYLE_MAX)
      {
        m_No.insert(style_no);
        error = false;
      }
    }
    
    if (error)
    {
      wxLogError(_("Illegal style: %s"), no.c_str());
    }
  }
}
int Model_Infotable::GetIntInfo(const wxString& key, int default_value)
{
    const wxString value = this->GetStringInfo(key, "");
    if (!value.IsEmpty() && value.IsNumber())
        return wxAtoi(value);

    return default_value;
}
Example #3
0
bool CPhone::parseAndFormat(const wxString& val, wxString& formattedNr)
{
  initClass();

  bool rc;
  if (isInternalNumber(val))
  {
    formattedNr = val;
    rc = val.IsNumber();
  }
  else
  {
    PhoneNumber phoneNr;
    std::string strCC        = m_Prefs->getPrefs().getCC();
    std::string strAC        = m_Prefs->getPrefs().getAC();
    bool        bAddAC       = m_Prefs->getPrefs().addACIfShortLen();
    int         nLocalMaxLen = m_Prefs->getPrefs().getLocalNrMaxLen();
    PhoneNumberUtil::ErrorType err = m_PhoneUtil->ParseAndKeepRawInput(
        val.ToUTF8().data(), strCC, &phoneNr);
    if (err == PhoneNumberUtil::NO_PARSING_ERROR)
    {
      std::string number;
      if (bAddAC && !strAC.empty() && (val.Length() < nLocalMaxLen))
      {
        // When we have an AreaCode set in the preferences and the number
        // entered is too short to contain an area code then add it and
        // parse/format again.
        // NOTE: Because Area Codes are ambiguous this can produce unexpected
        //       results or simply not work at all.
        std::string nsn;
        m_PhoneUtil->GetNationalSignificantNumber(phoneNr, &nsn);
        number  = strAC;
        number += nsn;
        err = m_PhoneUtil->Parse(number, strCC, &phoneNr);
        if (err == PhoneNumberUtil::NO_PARSING_ERROR) {
          m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::INTERNATIONAL, &number);
          formattedNr = wxString::FromUTF8(number.c_str());
          rc = true;
        } else {
          formattedNr = val;
          rc = false;
        }
      }
      else {
        m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::INTERNATIONAL, &number);
        formattedNr = wxString::FromUTF8(number.c_str());
        rc = true;
      }
    }
    else {
      formattedNr = val;
      rc = false;
    }
  }
  return rc;
}
Example #4
0
bool szHelpController::DisplaySection(const wxString& section) {
	int id;

	if (section.IsNumber()) 
		id = wxAtoi(section);
	else 
		id = GetId(section);

	return wxHtmlHelpControllerEx::DisplaySection(id);

}
Example #5
0
bool cmdListCtrl::onDelete(const wxString& item)
{
    if (g_config && item.IsNumber())
    {
        long id;
        item.ToLong(&id);
        if (id >= 0 && g_config->DeleteCmd(id))
            return true;
    }
    return false;
}
Example #6
0
static bool needsQuoting(wxString &value, bool forTypes)
{
	// Is it a number?
	if (value.IsNumber())
		return true;
	else
	{
		// certain types should not be quoted even though it contains a space. Evilness.
		wxString valNoArray;
		if (forTypes && value.Right(2) == wxT("[]"))
			valNoArray = value.Mid(0, value.Len() - 2);
		else
			valNoArray = value;

		if (forTypes &&
		        (!valNoArray.CmpNoCase(wxT("character varying")) ||
		         !valNoArray.CmpNoCase(wxT("\"char\"")) ||
		         !valNoArray.CmpNoCase(wxT("bit varying")) ||
		         !valNoArray.CmpNoCase(wxT("double precision")) ||
		         !valNoArray.CmpNoCase(wxT("timestamp without time zone")) ||
		         !valNoArray.CmpNoCase(wxT("timestamp with time zone")) ||
		         !valNoArray.CmpNoCase(wxT("time without time zone")) ||
		         !valNoArray.CmpNoCase(wxT("time with time zone")) ||
		         !valNoArray.CmpNoCase(wxT("\"trigger\"")) ||
		         !valNoArray.CmpNoCase(wxT("\"unknown\""))))
			return false;

		int pos = 0;
		while (pos < (int)valNoArray.length())
		{
			wxChar c = valNoArray.GetChar(pos);
			if (!((pos > 0) && (c >= '0' && c <= '9')) &&
			        !(c >= 'a' && c  <= 'z') &&
			        !(c == '_'))
			{
				return true;
			}
			pos++;
		}
	}

	// is it a keyword?
	const ScanKeyword *sk = ScanKeywordLookup(value.ToAscii());
	if (!sk)
		return false;
	if (sk->category == UNRESERVED_KEYWORD)
		return false;
	if (forTypes && sk->category == COL_NAME_KEYWORD)
		return false;
	return true;
}
Example #7
0
int GetSection(wxString& s)
{
    int i, f;
    long r = -1;
    i = s.First('[');
    f = s.Last(']');
    if (f > i)
    {
        s = s.Mid((i + 1), (f - i - 1));
        if (s.IsNumber())
            s.ToLong(&r);
        else
            r = -1;
    }
    return ((int) r);
}
bool interprete::interprete1(wxString linea)
{
    lenguajea2();
    bool si=false;
    int tempo=0,tempo2=0;
    polinomio respuestaAn;
    archivoDatos=fopen("TempInterprete.hs","w");
    archivoDebug=fopen("TempDebug.hs","w");
    fprintf(archivoDebug,L_Ev_Ope);
    if(linea.GetChar(0)=='+'||linea.GetChar(0)=='*')
    {
        return SINTAXIS_PRIMER;
    }
    if(linea.GetChar(0)=='/'||linea.GetChar(0)=='-'||linea.GetChar(0)=='?')
    {
        return SINTAXIS_PRIMER;
    }
    wxString subCadena,subCadena2;
    if(linea.IsNumber())
    {
        fprintf(archivoDebug,L_S_o);
        polinomio temp1[3],temp2;
        usi i=0,nums=0, nums2=0, nums3=0;
        subCadena=linea;
        nums=ObtenerNumDeOperacion(subCadena);
        nums2=ObtenerNumCharsOperacion(subCadena);
        for(i=0;i<nums;i++)
        {
            nums3=ObtenerNumCharsOperacion(subCadena,nums);
            temp1[i]=StringAPoli(subCadena);
        }
        si=true;
    }
    subCadena=linea.Mid(0,1);
    if(subCadena=='{')
    {
        fprintf(archivoDebug,L_S_o);
        pol=StringAPoli(linea.Mid(1,linea.length()));
	polinomio pm;
	if(linea.Find('+')!=-1)
	{
	    pm=pol.simplificar();
	}
	else if(linea.Find('-')!=-1)
	{
	    pm=pol.simplificar();
	}
	else if(linea.Find('*')!=-1)
	{
	    pm=pol.multiplicar();
	}
        //polinomio pm=pol.simplificar();
        wxString a=PoliAString(pm);
        fprintf(archivoDebug,a);
        si=true;
    }
    if(subCadena=="e"&&linea.GetChar(1)!='x')
    {
        factores=EXPONENCI;
        fprintf(archivoDebug,L_S_oe);
        subCadena2=linea.Mid(1,linea.length()-2);
        wxString exponTemp=ObtenerPolinomioParen(subCadena2);
        if(exponTemp=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        else
        {
            if(exponTemp.Contains('+')||exponTemp.Contains('-'))
            {
                fprintf(archivoDebug,L_Poli_De);
                fprintf(archivoDebug,"Interprete: Transformando de texto a polinomio\n");
                pol=StringAPoli(exponTemp);
                fprintf(archivoDebug,"Interprete: Transformando de polinomio a numero compuesto\n");
                com=PoliAComp(pol);
                fprintf(archivoDebug,"Interprete: Transformando de numero compuesto a numero real\n");
                rea=CompAReal(com);
            }
            else
            {
                fprintf(archivoDebug,"Interprete: Detectado Numero real o compuesto\n");
                fprintf(archivoDebug,"Interprete: haciendo tareas pertinentes\n");
                if(exponTemp.Contains('x')||exponTemp.Contains('y')||exponTemp.Contains('z'))
                {
                    com=StringAComp(exponTemp);
                }
                else
                {
                    rea=CompAReal(com);
                    double dou=UtilitariosBasicos::NumeroRealADouble(rea);
                    archivoRes=fopen("TempInterpreteRes.hs","w");
                    fprintf(archivoRes,"%f",exp(dou));
                    fclose(archivoRes);
                }
            }
            si=true;
        }
    }
    subCadena=linea.Mid(0,2);
    if(subCadena=="ln")
    {
        factores=LOGANATU;
        fprintf(archivoDebug,"Interprete: Operacion Logaritmo natural\n");
        subCadena2=linea.Mid(2,linea.length());
        wxString exponTemp=ObtenerPolinomioParen(subCadena2);
        if(exponTemp=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        else
        {
            if(exponTemp.Contains('+')||exponTemp.Contains('-'))
            {
                fprintf(archivoDebug,L_Poli_De);
                fprintf(archivoDebug,"Interprete: Transformando de texto a polinomio\n");
                pol=StringAPoli(exponTemp);
                fprintf(archivoDebug,"Interprete: Transformando de polinomio a numero compuesto\n");
                com=PoliAComp(pol);
                fprintf(archivoDebug,"Interprete: Transformando de numero compuesto a numero real\n");
                rea=CompAReal(com);
            }
            else
            {
                fprintf(archivoDebug,"Interprete: Detectado Numero real o compuesto\n");
                fprintf(archivoDebug,"Interprete: haciendo tareas pertinentes\n");
                if(exponTemp.Contains('x')||exponTemp.Contains('y')||exponTemp.Contains('z'))
                {
                    com=StringAComp(exponTemp);
                }
                else
                {
                    rea=CompAReal(com);
                    double dou=UtilitariosBasicos::NumeroRealADouble(rea);
                    archivoRes=fopen("TempInterpreteRes.hs","w");
                    fprintf(archivoRes,"%f",log(dou));
                    fclose(archivoRes);
                }
            }
            si=true;
        }
    }
    subCadena=linea.Mid(0,3);
    if(subCadena=="log")
    {
        factores=LOGARITMO;
        fprintf(archivoDebug,"Interprete: Operacion Logaritmo\n");
        subCadena2=linea.Mid(3,linea.length());
        usi exponTemp=ParenNumCarac(subCadena2);
        if(exponTemp==0)
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
            return si;
        }
        wxString exponTemp2=ObtenerPolinomioAntesComa(subCadena2);
        if(exponTemp2=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        wxString exponTemp3=ObtenerPolinomioDesComa(subCadena2,exponTemp);
        if(exponTemp3=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        else
        {
            if(exponTemp2.Contains('+')||exponTemp2.Contains('-')&&exponTemp3.Contains('+'))
            {
                fprintf(archivoDebug,L_Poli_De);
                fprintf(archivoDebug,"Interprete: Transformando de texto a polinomio\n");
                pol=StringAPoli(exponTemp2);
                pol2=StringAPoli(exponTemp3);
                fprintf(archivoDebug,"Interprete: Transformando de polinomio a numero compuesto\n");
                comp=PoliAComp(pol);
                comp2=PoliAComp(pol2);
                fprintf(archivoDebug,"Interprete: Transformando de numero compuesto a numero real\n");
                real=CompAReal(comp);
                real2=CompAReal(comp2);
                tempo=UtilitariosBasicos::NumRealAInt(real);
                tempo2=UtilitariosBasicos::NumRealAInt(real2);
                fprintf(archivoDebug,"Interprete: Enviando datos para operar en HugoMat\n");
            }
            else
            {
                fprintf(archivoDebug,"Interprete: Detectado Numero real o compuesto\n");
                fprintf(archivoDebug,"Interprete: haciendo tareas pertinentes\n");
                if(exponTemp2.Contains('x')||exponTemp2.Contains('y')||exponTemp2.Contains('z'))
                {
                    comp=StringAComp(exponTemp2);
                    comp2=StringAComp(exponTemp3);
                }
                else
                {
                    comp=StringAComp(exponTemp2);
                    comp2=StringAComp(exponTemp3);
                    real=CompAReal(comp);
                    real2=CompAReal(comp2);
                    tempo=UtilitariosBasicos::NumRealAInt(real);
                    tempo2=UtilitariosBasicos::NumRealAInt(real2);
                    fprintf(archivoDebug,"Interprete: Enviando datos para operar en HugoMat\n");
                    fprintf(archivoDebug, "%f", UtilitariosOperaciones::log(tempo,tempo2));
                    archivoRes=fopen("TempInterpreteRes.hs","w");
                    fprintf(archivoRes,"%f",UtilitariosOperaciones::log(tempo,tempo2));
                    fprintf(archivoRes, "\n");
                    fclose(archivoRes);
                }
            }
            cout<<UtilitariosOperaciones::log(tempo,tempo2)<<endl;
            si=true;
        }
        //si= true;
    }
    subCadena=linea.Mid(0,4);
    if(subCadena=="raiz")
    {
        factores=RAIZ;
        fprintf(archivoDebug,"Interprete: Operacion raiz\n");
        subCadena2=linea.Mid(4,linea.length());
        usi exponTemp=ParenNumCarac(subCadena2);
        if(exponTemp==0)
        {
            si=false;
        }
        wxString exponTemp2=ObtenerPolinomioAntesComa(subCadena2);
        if(exponTemp2=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        wxString exponTemp3=ObtenerPolinomioDesComa(subCadena2,exponTemp);
        if(exponTemp3=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        else
        {
            if(exponTemp2.Contains('+')||exponTemp2.Contains('-')&&exponTemp3.Contains('+'))
            {
                fprintf(archivoDebug,L_Poli_De);
                fprintf(archivoDebug,"Interprete: Transformando de texto a polinomio\n");
                pol=StringAPoli(exponTemp2);
                pol2=StringAPoli(exponTemp3);
                fprintf(archivoDebug,"Interprete: Transformando de polinomio a numero compuesto\n");
                comp=PoliAComp(pol);
                comp2=PoliAComp(pol2);
                fprintf(archivoDebug,"Interprete: Transformando de numero compuesto a numero real\n");
                real=CompAReal(comp);
                real2=CompAReal(comp2);
                tempo=UtilitariosBasicos::NumRealAInt(real);
                tempo2=UtilitariosBasicos::NumRealAInt(real2);
                fprintf(archivoDebug,"Interprete: Enviando datos para operar en HugoMat\n");
            }
            else
            {
                fprintf(archivoDebug,"Interprete: Detectado Numero real o compuesto\n");
                fprintf(archivoDebug,"Interprete: haciendo tareas pertinentes\n");
                if(exponTemp2.Contains('x')||exponTemp2.Contains('y')||exponTemp2.Contains('z'))
                {
                    comp=StringAComp(exponTemp2);
                    comp2=StringAComp(exponTemp3);
                }
                else
                {
                    comp=StringAComp(exponTemp2);
                    comp2=StringAComp(exponTemp3);
                    real=CompAReal(comp);
                    real2=CompAReal(comp2);
                    tempo=UtilitariosBasicos::NumRealAInt(real);
                    tempo2=UtilitariosBasicos::NumRealAInt(real2);
                    fprintf(archivoDebug,"Interprete: Enviando datos para operar en HugoMat\n");
                    fprintf(archivoDebug, "%f", UtilitariosOperaciones::rad(tempo,tempo2));
                    archivoRes=fopen("TempInterpreteRes.hs","w");
                    fprintf(archivoRes,"%f",UtilitariosOperaciones::rad(tempo,tempo2));
                    fprintf(archivoRes, "\n");
                    fclose(archivoRes);
                }
            }
            si=true;
        }
    }
    subCadena=linea.Mid(0,5);
    if(subCadena=="expon")
    {
        factores=POTENCIA;
        fprintf(archivoDebug,"Interprete: Operacion exponencial general\n");
        subCadena2=linea.Mid(5,linea.length());
        usi exponTemp=ParenNumCarac(subCadena2);
        if(exponTemp==0)
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        wxString exponTemp2=ObtenerPolinomioAntesComa(subCadena2);
        if(exponTemp2=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        wxString exponTemp3=ObtenerPolinomioDesComa(subCadena2,exponTemp);
        if(exponTemp3=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        else
        {
            if(exponTemp2.Contains('+')||exponTemp2.Contains('-')&&exponTemp3.Contains('+'))
            {
                fprintf(archivoDebug,L_Poli_De);
                fprintf(archivoDebug,"Interprete: Transformando de texto a polinomio\n");
                pol=StringAPoli(exponTemp2);
                pol2=StringAPoli(exponTemp3);
                fprintf(archivoDebug,"Interprete: Transformando de polinomio a numero compuesto\n");
                comp=PoliAComp(pol);
                comp2=PoliAComp(pol2);
                fprintf(archivoDebug,"Interprete: Transformando de numero compuesto a numero real\n");
                real=CompAReal(comp);
                real2=CompAReal(comp2);
                tempo=UtilitariosBasicos::NumRealAInt(real);
                tempo2=UtilitariosBasicos::NumRealAInt(real2);
                fprintf(archivoDebug,"Interprete: Enviando datos para operar en HugoMat\n");
            }
            else
            {
                fprintf(archivoDebug,"Interprete: Detectado Numero real o compuesto\n");
                fprintf(archivoDebug,"Interprete: haciendo tareas pertinentes\n");
                if(exponTemp2.Contains('x')||exponTemp2.Contains('y')||exponTemp2.Contains('z'))
                {
                    comp=StringAComp(exponTemp2);
                    comp2=StringAComp(exponTemp3);
                }
                else
                {
                    comp=StringAComp(exponTemp2);
                    comp2=StringAComp(exponTemp3);
                    real=CompAReal(comp);
                    real2=CompAReal(comp2);
                    tempo=UtilitariosBasicos::NumRealAInt(real);
                    tempo2=UtilitariosBasicos::NumRealAInt(real2);
                    fprintf(archivoDebug,"Interprete: Enviando datos para operar en HugoMat\n");
                    fprintf(archivoDebug, "%f", UtilitariosOperaciones::expon(tempo,tempo2));
                    archivoRes=fopen("TempInterpreteRes.hs","w");
                    fprintf(archivoRes,"%f",UtilitariosOperaciones::expon(tempo,tempo2));
                    fprintf(archivoRes, "\n");
                    fclose(archivoRes);
                }
            }
            si=true;
        }
    }
    subCadena=linea.Mid(0,8);
    if(subCadena=="integral")
    {
        factores=INTEGRAL;
        fprintf(archivoDebug,"Interprete: Operacion integral\n");
        subCadena2=linea.Mid(8,linea.length());//En integral no aplica FIXME
        usi exponTemp=ParenNumCarac(subCadena2);//Numero de chars antes de ','
        if(exponTemp==0)
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        wxString exponTemp2=ObtenerPolinomioAntesComa(subCadena2);//RegresaElString desde 1parentesis hasta coma
        if(exponTemp2=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        wxString exponTemp3=ObtenerPolinomioDesComa(subCadena2,exponTemp);//RegresaStringDesdeComaAParentesis
        if(exponTemp3=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        usi exponTemp4=ObtenerNumChars(linea);//regresa el numero de chars desde inicio hasta '{'
	subCadena2=linea.Mid(exponTemp4,linea.length());
        subCadena2=ObtenerPolinomioParen(subCadena2);//Selec�SupuestamenteDesdeLa{
        if(exponTemp4==0/*||exponTemp5=="error"*/)
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        else
        {
            if(subCadena2.Contains('+')||subCadena2.Contains('-'))
            {
                fprintf(archivoDebug,L_Poli_De);
                fprintf(archivoDebug,"Interprete: Transformando de texto a polinomio\n");
                pol=StringAPoli(subCadena2);
		polinomio poliT;
		NumeroComp NumResultado;
		if(exponTemp2.IsNumber()&&exponTemp3.IsNumber())
		{
		    double ba,bb;
		    double *a=&ba,*b=&bb;
		    exponTemp2.ToDouble(a);
		    exponTemp3.ToDouble(b);
		    NumResultado.CambiarNumero(UtilitariosOperaciones::integralD(NumeroReal((int)ba,1),NumeroReal((int)bb,1),pol));
		    CompAString(NumResultado);
		}
		else
		{
		    poliT=UtilitariosOperaciones::integral(pol);
		    PoliAString(poliT);
		}
		
            }
            else
            {
                fprintf(archivoDebug,"Interprete: Detectado Numero real o compuesto\n");
                fprintf(archivoDebug,"Interprete: haciendo tareas pertinentes\n");
                if(subCadena2.Contains('x')||subCadena2.Contains('y')||subCadena2.Contains('z'))
                {
                    com=StringAComp(subCadena2);
                    fprintf(archivoDebug,"Interprete: Enviando datos para operar en HugoMat\n");
		    NumeroComp te;
		    fprintf(archivoDebug,exponTemp2);
		    fprintf(archivoDebug,exponTemp3);
		    if(exponTemp3.Find('(')||exponTemp3.Find('{'))
		    {
			exponTemp3.RemoveLast();
			exponTemp3.RemoveLast();
		    }
		    fprintf(archivoDebug,exponTemp2);
		    fprintf(archivoDebug,exponTemp3);
		    if(exponTemp2.IsNumber()&&exponTemp3.IsNumber())
		    {
			double ba,bb;
			double *a=&ba,*b=&bb;
			exponTemp2.ToDouble(a);
			exponTemp3.ToDouble(b);
			te.CambiarNumero(UtilitariosOperaciones::integralD(NumeroReal((int)ba,1),NumeroReal((int)bb,1),pol));
			//NumeroComp te=intermediario.integralD(com);			
		    }
		    else
		    {
			NumeroComp te=UtilitariosOperaciones::integral(com);
		    }
		    CompAString(te);
                }
                si=true;
            }
        }
    }
    else if(subCadena=="derivada")
    {
        factores=DERIVADA;
        fprintf(archivoDebug,"Interprete: Operacion derivada\n");
        subCadena2=linea.Mid(8,linea.length());
        wxString exponTemp=ObtenerPolinomioParen(subCadena2);
        if(exponTemp=="error")
        {
            fprintf(archivoDebug,L_NoArg);
            si=false;
        }
        else
        {
            if(exponTemp.Contains('+')||exponTemp.Contains('-'))
            {
                fprintf(archivoDebug,L_Poli_De);
                fprintf(archivoDebug,"Interprete: Transformando de texto a polinomio\n");
                pol=StringAPoli(exponTemp);
                polinomio poliT=UtilitariosOperaciones::derivada(pol);
		PoliAString(poliT);
            }
            else
            {
                fprintf(archivoDebug,"Interprete: Detectado Numero real o compuesto\n");
                fprintf(archivoDebug,"Interprete: haciendo tareas pertinentes\n");
                if(exponTemp.Contains('x')||exponTemp.Contains('y')||exponTemp.Contains('z'))
                {
		    
                    com=StringAComp(exponTemp);
                    fprintf(archivoDebug,"Interprete: Enviando datos para operar en HugoMat\n");
                    NumeroComp te=UtilitariosOperaciones::derivada(com);
		    CompAString(te);
                }
                else
                {
		    com.CambiarNumerador(0);
		    CompAString(com);
                }
            }
            si=true;
        }
    }
    fclose(archivoDatos);
    fclose(archivoDebug);
    return si;
}