Esempio n. 1
0
char* pValue::toStr()
{
    int i1, i2;
    char *tval = new char[16];
    switch(type) {
	case SHORTINT:
	    return fcvt(*(short*)data, 0, &i1, &i2);
	    break;
	case INTEGER:
	    return fcvt(*(int*)data, 0, &i1, &i2);
	    break;
	case DOUBLE:
	    gcvt(*(double*)data, 8, tval);
	    return tval;
	    break;
	case STRING:
	    return data;
	    break;
	default:
	    //BUG
	    
	    return NULL;
    };
    
}
Esempio n. 2
0
LPTSTR CArborEdit::FloatToString(LPTSTR buff,double r)
{
	_TCHAR *buffer;
	LPTSTR startbuffptr;
	int dec,sign;  // must use static, don't assume SS==DS
	int i;

	startbuffptr = buff;

	if (EditStyleIs(EDIT_CURRENCY))
	{
		buffer = fcvt((double)r, m_iCurDigits, &dec, &sign);
		*buff++ = m_cCurrency1;
		if( m_cCurrency2 != ' ') *buff++ = m_cCurrency2;
		// copy the negative sign if less than zero
		if (sign) *buff++ = '-';

		if( dec <= 0 ) *buff++ = '0'; 
		// copy the non-fractional part before the decimal place
		for(i=0; i<dec; i++)
		{
			if( ((dec-i) % 3 ) == 0 && (i !=0 ) ) *buff++ = m_cThousand;
			*buff++ = *buffer++;
		}
		// copy the decimal point into the string 
		*buff++ =  m_cDecimal;
		if ( dec < 0 )
			for( i = 1; i <=  m_iCurDigits &&  i <= (dec * (-1)); *buff++ = '0', i++ );
	}
	else if(EditStyleIs(EDIT_FLOAT))
	{
		buffer = fcvt((double)r, m_iNumberOfDigits, &dec, &sign);
		// copy the negative sign if less than zero
		if (sign) *buff++ = '-';
		if( dec <= 0 ) *buff++ = '0'; 
		// copy the non-fractional part before the decimal place
		for(i=0; i<dec; *buff++ = *buffer++, i++);
		// copy the decimal point into the string 
		*buff++ =  '.';

		if ( dec < 0 )
			for( i = 1; i <= m_iNumberOfDigits &&  i <= (dec * (-1)); *buff++ = '0', i++ );
	}
	else 	 
		return buff;
 
	*buff = '\0';   // don't assume NULL termination
	// copy the fractional part after the decimal place
	lstrcat(buff,buffer);
	buff = startbuffptr;
	return startbuffptr;
}
Esempio n. 3
0
int main(void)
{
	double value;
	char *pstr;
	int dec, sign;

	value=3.1415926535;
	pstr=fcvt(value,6,&dec,&sign);
	printf("문자열 : %s, 소수점 위치 : %d, 부호는 %d,",pstr,dec,sign);
	
	value=-3.1415926535;
	pstr=fcvt(value,8,&dec,&sign);
	printf("문자열 : %s, 소수점 위치 : %d, 부호는 %d,",pstr,dec,sign);

	return 0;
}
Esempio n. 4
0
CStringEx CTypeUnitDouble::FormatDouble( const double dvalue ) const
{
	int  decimal, sign;
	char *buffer;

	if( dvalue == 0 )
		return( CStringEx( "0.0" ));

#ifdef NL_OS_WINDOWS
	buffer = _fcvt( dvalue, 5, &decimal, &sign );
#else
	buffer = fcvt( dvalue, 5, &decimal, &sign ); 
#endif // NL_OS_WINDOWS
	CStringEx sx( buffer );
	if( decimal <= 0 )
	{
		sx = (std::string)(CStringEx( "0." ) + CStringEx( '0', -decimal ) + sx);
	}
	else
		sx.insert(decimal,".");

	while( sx[sx.length()-1] == '0' )
		sx.left( (int)sx.length() -1 );
	
	if( sx[sx.length()-1] == '.' )
		sx += '0';
	
	if( sign )
		sx = CStringEx( "-" + sx );

	return sx;
}
Esempio n. 5
0
int printf(char *fmt,...){
	int next=0;
	va_list ap;
	va_start(ap,fmt);
	while(*fmt){
		if(*fmt=='%'){
			next=*(fmt+1);
			if(next=='l') next++;
			if(next=='d') {
				char buf[100];
				puts(itoa(va_arg(ap,int),buf,10));
			}
			if(next=='s') puts(va_arg(ap,char*));
			if(next=='f') {
				/**/
				int p,v;
				double d=va_arg(ap,double);
				/*
					char buf[50];
					gcvt(d,10,buf);
					printf(buf);
				*/
				char *pt=fcvt(d,10,&p,&v);
				int r=0;
				while(*pt){
					if(r==p) putchar('.');
					putchar(*pt);
					pt++;
					r++;
				}
			}
Esempio n. 6
0
static void
special (void)
{
  int decpt, sign, res;
  char *p;
  char buf [1024];

  p = ecvt (NAN, 10, &decpt, &sign);
  if (sign != 0 || strcmp (p, "nan") != 0)
    output_error ("ecvt", NAN, 10, "nan", 0, 0, p, decpt, sign);

  p = ecvt (INFINITY, 10, &decpt, &sign);
  if (sign != 0 || strcmp (p, "inf") != 0)
    output_error ("ecvt", INFINITY, 10, "inf", 0, 0, p, decpt, sign);

  /* Simply make sure these calls with large NDIGITs don't crash.  */
  (void) ecvt (123.456, 10000, &decpt, &sign);
  (void) fcvt (123.456, 10000, &decpt, &sign);

  /* Some tests for the reentrant functions.  */
  /* Use a too small buffer.  */
  res = ecvt_r (123.456, 10, &decpt, &sign, buf, 1);
  if (res == 0)
    {
      printf ("ecvt_r with a too small buffer was succesful.\n");
      ++error_count;
    }
  res = fcvt_r (123.456, 10, &decpt, &sign, buf, 1);
  if (res == 0)
    {
      printf ("fcvt_r with a too small buffer was succesful.\n");
      ++error_count;
    }
}
Esempio n. 7
0
static double SliderIntervalRound(double fValue, double fInterval,
                                  double fMin, double fMax,
                                  WORD wParam)
{
    if (fInterval == 0.0)
        return fValue;

    if (fValue > fMax)
        return fMax;
    else if (fValue < fMin)
        return fMin;
    
    if ((double) (long) fInterval == fInterval &&
        (double) (long) fValue == fValue)
    {
        int dec, sign;
        return atof(fcvt(fValue, 0, &dec, &sign));
    }
    else
    {
        double dInterval = fInterval / 100000;

        if (wParam == SB_LINEUP)
        {
            fValue = floor((fValue - fMin) / dInterval) * dInterval + fMin;
            return ceil(fValue * 100000) / 100000;
        }
        else
        {
            fValue = ceil((fValue - fMin) / dInterval) * dInterval + fMin;
            return floor(fValue * 100000) / 100000;
        }
    }
}
int main (int argc, char * argv[])
{
	double valeur;
	int    nb_chiffres;
	int    position;
	int    signe;
	char * retour;
	
	if ((argc != 3) 
	 || (sscanf(argv[1], "%lf", & valeur) != 1)
	 || (sscanf(argv[2], "%d", & nb_chiffres) != 1)) {
		fprintf(stderr, "Syntaxe : %s valeur nb_chiffres \n", argv[0]);
		exit (EXIT_FAILURE);
	}
	retour = ecvt(valeur, nb_chiffres, & position, & signe);
	fprintf(stdout, "ecvt() = %s \n", retour);
	fprintf(stdout, "    position = %d \n", position);
	fprintf(stdout, "    signe = %d \n", signe);

	retour = fcvt(valeur, nb_chiffres, & position, & signe);
	fprintf(stdout, "fcvt() = %s \n", retour);
	fprintf(stdout, "    position = %d \n", position);
	fprintf(stdout, "    signe = %d \n", signe);

	return EXIT_SUCCESS;
}
Esempio n. 9
0
/*
 *  Returns a null terminated formatted string.
 *  If error is encountered, such as malloc() failed, then return NULL.
 *  The caller of this function should beware that the return value is
 *  a static buffer declared within this function and the value of it may
 *  change.
 */
char *
cm_printf(double value, int decimal_pt)
{
	int sign = 0;
	int deci_pt = 0;
	int buf_cnt = 0;
	int formatted_cnt = 0;
	int buf_len = 0;
	char *buf = NULL;
	static char *formatted = NULL;

	if ( formatted != NULL ) {
		free(formatted);
		formatted = NULL;
	}
	if ( (value == (double)0) && (decimal_pt == 0) ) {
		formatted = (char *)cm_strdup("0");
		return formatted;
	}
	if ( (buf = (char *)malloc(DBL_SIZE + decimal_pt)) == NULL ) {
		return (char *)NULL;
	}
	if ( (formatted = (char *)calloc(1, DBL_SIZE + decimal_pt)) == NULL ) {
		free(buf);
		return (char *)NULL;
	}
#ifdef SunOS
	fconvert(value, decimal_pt, &deci_pt, &sign, buf);
#elif defined(CSRG_BASED)
	snprintf(buf, decimal_pt, "%f", value);
#else
	/* this version, available on the HP and AIX machine is not reentrant. */

	strcpy(buf, fcvt(value, decimal_pt, &deci_pt, &sign));
#endif
	if ( sign ) {
		strcpy(formatted, "-");
	}
	buf_len = deci_pt + decimal_pt;
	if ( deci_pt ) {
		strncat(formatted, buf, deci_pt);
	} else {    /* zero */
		strcat(formatted, "0");	
	}
	if ( deci_pt == buf_len ) {
		strcat(formatted, "\0");
		free(buf);
		return formatted;
	}
	strcat(formatted, ".");
	for ( formatted_cnt = strlen(formatted), buf_cnt = deci_pt;  buf_cnt < buf_len;  buf_cnt++, formatted_cnt++ ) {
		formatted[formatted_cnt] = buf[buf_cnt];
	}
	formatted[formatted_cnt] = '\0';
	free(buf);
	return formatted;	
}
Esempio n. 10
0
int main() {
  int decimal, sign;
  char *buffer;
  double source = 3.1415926535;

  buffer = fcvt(source, 7, &decimal, &sign);
  printf("source: %2.10f   buffer: '%s'   decimal: %d   sign: %d\n", source,
         buffer, decimal, sign);
}
Esempio n. 11
0
void testValues() {
    f = 2;
    
    int d,n;
    char* result = fcvt(anydouble(), anyint(), &d, &n);
    //@ assert \valid(result);

    //@ assert f == 2;
    //@ assert vacuous: \false;
}
Esempio n. 12
0
double conversion(float w)
	{
		int punto_d,signo;
		char*cadena;
		double r,s;
		cadena=fcvt(w,4,&punto_d,&signo);
		r=atof(cadena);
		w=r/10000;
		if (signo==1)
		    w = w * (-1);
		return(w);
	}
Esempio n. 13
0
/*double conversion(float w)
	{
		int punto_d,signo;
		char*cadena;
		double r,s;
		cadena=fcvt(w,4,&punto_d,&signo);
		r=atof(cadena);
		w=r/10000;
		if (signo==1)
		    w = w * (-1);
		return(w);
	}*/
double conversion(double w)
{
       cadena=fcvt(valor,5,&punto_d,&signo);
       r=atof(cadena);
       valor2=r/100000;
       if (signo==1)
       valor2 = valor2 * (-1);
       divi=valor2/0.0001;
       cadena2=fcvt(valor,4,&punto_d,&signo);
       valor3=atoi(cadena2);
       resta= valor3 - divi;
       if (resta > 0 )
       {
	     w= (valor3 - 1)* 0.0001;
       }
       if (resta < 0)
       {
	     w = valor3 * 0.0001;
       }
       return(w);
}
RGString RGXmlDataFractionDigits :: BuildString (const RGPScalar& p, int& param1, int& param2) {

	int fractionalDigits = SizeLimit;
	char* str;
	double d = p.GetDouble ();
	int decimalPoint;
	int sign;
	str = fcvt (d, fractionalDigits, &decimalPoint, &sign);
	RGString Result = str;
	param1 = decimalPoint;
	param2 = sign;
	return Result;
}
Esempio n. 15
0
CString Speller::GetFract(double d,int prec){
	
	if(!prec)return "";
	d-=floor(d);
	int i,j;
	LPTSTR ts;
	if(prec<0){
		ts=fcvt(d,20,&i,&j);
		if('0'==*ts)return "";
		for(LPTSTR tail=ts+19;ts<tail;tail--){
			if('0' == *tail)*tail='\0';	//убираем конечные нули
			else break; //до 1-го ненулевого символа.
		}
		CString rez('0',i);
		rez+=ts;
		return rez;
	}
	
	d+=1;
	ts=fcvt(d,prec,&i,&j);
	CString rez(ts+1);
	return rez;
	
}
char *code_message(msg *a){
    char *coded_msg=(char *)malloc(sizeof(int)*5+sizeof(double)+300*sizeof(char)+20);
    coded_msg[0]='\0';
    char num[10];
  
   	snprintf(num,10,"%d",a->sender_id);
    strcat(coded_msg,num);
    strcat(coded_msg," ");
  
    snprintf(num,10,"%d",a->receiver_id);
    strcat(coded_msg,num);
    strcat(coded_msg," ");
  
	snprintf(num,10,"%d",a->msg_type);
    strcat(coded_msg,num);
    strcat(coded_msg," ");	    


    int dec_pl,sign;
    strcat(coded_msg,fcvt((double) a->timestamp, 0, &dec_pl, &sign));
    strcat(coded_msg," ");
    
    snprintf(num,10,"%d",a->coming_from);
    strcat(coded_msg,num);
    strcat(coded_msg," ");      
  

    snprintf(num,10,"%d",a->message_id);
    strcat(coded_msg,num);
    strcat(coded_msg," ");

    strcat(coded_msg," ");
    strcat(coded_msg,a->message);
  
 // 	puts("This is encoded string:");
 // 	puts(coded_msg);
    return coded_msg;
}
Esempio n. 17
0
int Algoritms::SaveStates(char *name,char *AlgTaskName[maxcrits],
			  char *AlgProcName[3],task far* tasklistptr)
   {
   int handle,retvalue;
   UINT MaxLgTakt,MaxLgProc,MaxLgTask;
   UCHAR NumbTask=0,NumbProc=0;
   char *CopyRight=
" ╔════════════════════════════════════════════════════════════════════════════╗\n"
" ║                      PARALLEL    PROCESSOR   SCHEDULER                     ║\n"
" ║                                 Version 1.1                                ║\n"
" ║                                (C)  Feedback                               ║\n"
" ╚════════════════════════════════════════════════════════════════════════════╝\n\n";
   char *value=
      "                                                                      \n";
   char *AlgTaskMsg=
      " Алгоритм выбора задач:                                               \n";
   char *AlgProcMsg=
      "    - по минимуму индекса                                             \n"
      " Алгоритм выбора процессоров:                                         \n"
      "    -                                                                 \n"
      "    - по минимуму индекса                                             \n";
   char *TitleMessage=
      " Число Задач:        Число процессоров:        Критический путь:      \n"
      " ┌─────────────┬────────────┬───────────────────┬─────────────────┐   \n"
      " │    Номер    │   Номер    │ Время постановки  │ Время окончания │   \n"
      " │    задачи   │ процессора │   на выполнение   │     решения     │   \n"
      " ├─────────────┼────────────┼───────────────────┼─────────────────┤   \n";
   char *Mesg=
      " │             │            │                   │                 │   \n";
   char *TitleDone=
      " └─────────────┴────────────┴───────────────────┴─────────────────┘   \n"
      " Время решения =>                                                     \n"
      " Коэффициенты загруженности процессоров :                             \n";
   char *Charge=
      "    Процессор    :    Время работы =>       Загруженность => 0.       \n";
   char *Str=
      "\n────────────────────────────────────────────────────────────────────────────────\n\n";
   tasks=tasklistptr;
   itoa(time,value,10);
   MaxLgTakt=strlen(value);
   itoa(cntprocs,value,10);
   MaxLgProc=strlen(value);
   itoa(cnttasks,value,10);
   MaxLgTask=strlen(value);
   if ((handle=
      open(name,O_APPEND|O_TEXT|O_RDWR,S_IREAD|S_IWRITE))==-1)
      {
      if ((handle=
	 open(name,O_CREAT|O_APPEND|O_TEXT|O_RDWR,S_IREAD|S_IWRITE))==-1)
	 return io_error;
      if (write(handle,CopyRight,80*5+1)!=80*5+1)
	 {
	 close(handle);
	 return io_error;
	 }
      }
   if (write(handle,AlgTaskMsg,71)!=71)
      {
      close(handle);
      return io_error;
      }
   for (int i=1; i<=cntcrits; i++)
      {
      strcpy(value,"    - ");
      strcpy(&value[6],AlgTaskName[critslist[i]-1]);
      if (write(handle,value,71)!=71)
	 {
	 close(handle);
	 return io_error;
	 }
      }
   strcpy(&AlgProcMsg[71*2+6],AlgProcName[charge]);
   if (write(handle,AlgProcMsg,71*4)!=71*4)
      {
      close(handle);
      return io_error;
      }
   strcpy(value,AlgTaskName[critslist[i]-1]);
   itoa(cnttasks,value,10);
   strcpy(&TitleMessage[15],value);
   itoa(cntprocs,value,10);
   strcpy(&TitleMessage[41],value);
   itoa(critway,value,10);
   strcpy(&TitleMessage[66],value);
   if (write(handle,TitleMessage,71*5)!=71*5)
      {
      close(handle);
      return io_error;
      }
   while (++NumbTask<=cnttasks)
      {
      itoa(NumbTask,value,10);
      strcpy(&Mesg[7+MaxLgTask-strlen(value)],value);
      itoa(taskstate[NumbTask].procnumber,value,10);
      strcpy(&Mesg[21+MaxLgProc-strlen(value)],value);
      itoa(taskstate[NumbTask].begtime,value,10);
      strcpy(&Mesg[37+MaxLgTakt-strlen(value)],value);
      itoa(taskstate[NumbTask].begtime+tasks[NumbTask].weight-1,value,10);
      strcpy(&Mesg[56+MaxLgTakt-strlen(value)],value);
      if (write(handle,Mesg,71)!=71)
	 {
	 close(handle);
	 return io_error;
	 }
      strcpy(&Mesg[7],"     ");
      strcpy(&Mesg[21],"     ");
      strcpy(&Mesg[37],"     ");
      strcpy(&Mesg[56],"     ");
      }
   itoa(time-1,value,10);
   strcpy(&TitleDone[89],value);
   if (write(handle,TitleDone,71*3)!=71*3)
      {
      close(handle);
      return io_error;
      }
   while (++NumbProc<=cntprocs)
      {
      int dec,sign;
      double kfc;
      itoa(NumbProc,value,10);
      strcpy(&Charge[14+MaxLgProc-strlen(value)],value);
      itoa(procs[NumbProc].chargetime,value,10);
      strcpy(&Charge[38+MaxLgTakt-strlen(value)],value);
      kfc=((float)procs[NumbProc].chargetime)/((float)(time-1));
      value=fcvt(kfc,5,&dec,&sign);
      if (procs[NumbProc].chargetime!=time-1) strcpy(&Charge[63],value);
	 else
	    strcpy(&Charge[61],"1.00000");
      if (write(handle,Charge,71)!=71)
	 {
	 close(handle);
	 return io_error;
	 }
      strcpy(&Charge[14],"   :");
      if (procs[NumbProc].chargetime!=time-1) strcpy(&Charge[63],"     ");
	 else
	    strcpy(&Charge[61],"0.    ");
      }
   write(handle,Str,82);
   close(handle);
   return io_ok;
   }
Esempio n. 18
0
/*
 * Convert a floating point number to a string formats 'f', 'e' or 'E'.
 * The result is placed in buf, and len denotes the length of the string
 * The sign is returned in the is_negative argument (and is not placed
 * in buf).  Always add decimal point if add_dp is YES.
 */
static char *
conv_fp(char format, double num, boolean_e add_dp, int precision, bool_int * is_negative, char buf[], int *len)
{
   char     *s = buf;

   char     *p;

   int       decimal_point;

   if (format == 'f')
      p = fcvt(num, precision, &decimal_point, is_negative);
   else				/* either e or E format */
      p = ecvt(num, precision + 1, &decimal_point, is_negative);

  /*
   * Check for Infinity and NaN
   */
   if (isalpha(*p))
    {
       *len = strlen(strcpy(buf, p));
       *is_negative = FALSE;
       return (buf);
    }
   if (format == 'f')
      if (decimal_point <= 0)
       {
	  *s++ = '0';
	  if (precision > 0)
	   {
	      *s++ = '.';
	      while (decimal_point++ < 0)
		 *s++ = '0';
	   }
	  else if (add_dp)
	     *s++ = '.';
       }
      else
       {
	  while (decimal_point-- > 0)
	     *s++ = *p++;
	  if (precision > 0 || add_dp)
	     *s++ = '.';
       }
   else
    {
       *s++ = *p++;
       if (precision > 0 || add_dp)
	  *s++ = '.';
    }

  /*
   * copy the rest of p, the NUL is NOT copied
   */
   while (*p)
      *s++ = *p++;

   if (format != 'f')
    {
       char      temp[EXPONENT_LENGTH];	/* for exponent conversion */

       int       t_len;

       bool_int  exponent_is_negative;

       *s++ = format;		/* either e or E */
       decimal_point--;
       if (decimal_point != 0)
	{
	   p = conv_10((wide_int) decimal_point, FALSE, &exponent_is_negative, &temp[EXPONENT_LENGTH], &t_len);
	   *s++ = exponent_is_negative ? '-' : '+';

	  /*
	   * Make sure the exponent has at least 2 digits
	   */
	   if (t_len == 1)
	      *s++ = '0';
	   while (t_len--)
	      *s++ = *p++;
	}
       else
	{
	   *s++ = '+';
	   *s++ = '0';
	   *s++ = '0';
	}
    }
   *len = s - buf;
   return (buf);
}
Esempio n. 19
0
/*
 * Convert a floating point number to a string formats 'f', 'e' or 'E'.
 * The result is placed in buf, and len denotes the length of the string
 * The sign is returned in the is_negative argument (and is not placed
 * in buf).
 */
static char *conv_fp(register char format, register double num,
    boolean_e add_dp, int precision, int *is_negative,
    char *buf, size_t *len)
{
    register char *s = buf;
    register char *p;
    int decimal_point;
    char buf1[NDIG];

    if (format == 'f')
        p = fcvt(num, precision, &decimal_point, is_negative, buf1);
    else /* either e or E format */
        p = ecvt(num, precision + 1, &decimal_point, is_negative, buf1);

    /*
     * Check for Infinity and NaN
     */
    if (isalpha(*p)) {
        *len = strlen(p);
        memcpy(buf, p, *len + 1);
        *is_negative = FALSE;
        return (buf);
    }

    if (format == 'f') {
        if (decimal_point <= 0) {
            *s++ = '0';
            if (precision > 0) {
                *s++ = '.';
                while (decimal_point++ < 0)
                    *s++ = '0';
            }
            else if (add_dp)
                *s++ = '.';
        }
        else {
            while (decimal_point-- > 0)
                *s++ = *p++;
            if (precision > 0 || add_dp)
                *s++ = '.';
        }
    }
    else {
        *s++ = *p++;
        if (precision > 0 || add_dp)
            *s++ = '.';
    }

    /*
     * copy the rest of p, the NUL is NOT copied
     */
    while (*p)
        *s++ = *p++;

    if (format != 'f') {
        char temp[EXPONENT_LENGTH];        /* for exponent conversion */
        size_t t_len;
        int exponent_is_negative;

        *s++ = format;                /* either e or E */

		//
		// XXX: without the check the routine converts 0.0 to "0.0e-1"
		//
		if (num != 0.0)
			decimal_point--;
        if (decimal_point != 0) {
            p = conv_10((int32_t) decimal_point, FALSE, &exponent_is_negative,
                        &temp[EXPONENT_LENGTH], &t_len);
            *s++ = exponent_is_negative ? '-' : '+';

            /*
             * Make sure the exponent has at least 2 digits
             */
            if (t_len == 1)
                *s++ = '0';
            while (t_len--)
                *s++ = *p++;
        }
        else {
            *s++ = '+';
            *s++ = '0';
            *s++ = '0';
        }
    }

    *len = s - buf;
    return (buf);
}
Esempio n. 20
0
// Umwandlung eines Double-Wertes entsprechend Format-String 
// in eine Zeichenkette
char *DtoA (double Wert, char *String, const char *Format) 
{
register int Laenge;
register int StrLaenge;
int NachKomma = 0;
int KommaPos;
int Sign;
char *lpA;
char *lpB;

//  prüfe Parameter
	if (Format == NULL)
		Format = DoubleFormat;

	lpA = (char *) Format + strcspn (Format, "0123456789");
	lpB = strchr (Format, '.');
	if (lpB) 
		NachKomma = atoi (lpB+1);
	else {
		lpB = lpA;
		NachKomma = 3;
	}
	if (lpA <= lpB) 
		Laenge = atoi (lpA);
	else
		Laenge = 7;
	lstrcpy (String, fcvt (Wert, NachKomma, &KommaPos, &Sign));
	if (KommaPos <= 0) {
	    StrInsNChr (String, '0', 0, abs (KommaPos) + 1);
	    StrInsNChr (String, '.', 1, 1);
	}
	else
	    StrInsNChr (String, '.', KommaPos, 1);
	if (*(strchr(Format, '%')+1) == '+') {
		if (!Sign)
			StrInsNChr (String, '+', 0, 1);
	}
	if (Sign)
		StrInsNChr (String, '-', 0, 1);
	if (!strchr (Format, '-') &&   // wenn keine linksbündige Ausgabe
	    (Laenge > (StrLaenge = lstrlen(String))))
		StrInsNChr (String, ' ', 
			(String[1] == '0' && (*String == '-' || *String == '+')) ?
				1 : 0, Laenge - StrLaenge);
	if (String[Laenge = (lstrlen(String) -1)] == '.')
		String[Laenge] = '\0';

//  führende Leerzeichen ggf. Löschen        
	char *pStringTmp = '\0';
	char *pFirstCh = '\0';
	if (*String == ' ')
	{
	// 	1. gültige Zeichen suchen
		pFirstCh = String;
		while (*pFirstCh != '\0' && *pFirstCh == ' ')
			pFirstCh++;

	// 	String umkopieren
		pStringTmp = String;
		while (*pFirstCh != '\0')
			*pStringTmp++ = *pFirstCh++;

		*pStringTmp = '\0';     // Endekennzeichen setzen
	}
	
//	alle Nullen nach dem Dezimalpunkt löschen
	pStringTmp = &String [lstrlen (String) - 1];			// auf Letzte Zeichen	    
	while (*pStringTmp != '.' && *pStringTmp == '0')
		*pStringTmp-- = '\0';	
		
//	Dezimalpunkt ggf. auch löschen
	if (*pStringTmp == '.')
		*pStringTmp = '\0';		

	return String;
}
Esempio n. 21
0
inline char* _Stl_qfcvtR(long double x, int n, int* pt, int* sign, char* )
{ return fcvt(x, n, pt, sign); }
char *
dtoa(double d,       // IN
     int mode,       // IN
     int prec,       // IN
     int *expOut,    // OUT
     int *sign,      // OUT
     char **strEnd)  // OUT
{
   char *str = NULL;
   int dec;

#if defined(_WIN32)
   if (2 == mode) {
      str = malloc(_CVTBUFSIZE);
      if (str) {
         if (_ecvt_s(str, _CVTBUFSIZE, d, prec, &dec, sign)) {
            free(str);
            str = NULL;
         }
      }
   } else {
      ASSERT(3 == mode);
      str = malloc(_CVTBUFSIZE);
      if (str) {
         if (_fcvt_s(str, _CVTBUFSIZE, d, prec, &dec, sign)) {
            free(str);
            str = NULL;
         }
      }

      /*
       * When the value is not zero but rounds to zero at prec digits,
       * the Windows fcvt() sometimes returns the empty string and
       * a negative dec that goes too far (as in -dec > prec).
       * For example, converting 0.001 with prec 1 results in
       * the empty string and dec -2.  (See bug 253674.)
       *
       * We just clamp dec to -prec when this happens.
       *
       * While this may appear to be a safe and good thing to
       * do in general.  It really only works when the result is
       * all zeros or empty.  Since checking for all zeros is
       * expensive, we only check for empty string, which works
       * for this bug.
       */

      if (str && *str == '\0' && dec < 0 && dec < -prec) {
	 dec = -prec;
      }
   }
#else // _WIN32
   static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

   if (2 == mode) {
      pthread_mutex_lock(&mutex);
      str = strdup(ecvt(d, prec, &dec, sign));
      pthread_mutex_unlock(&mutex);
   } else {
      ASSERT(3 == mode);

#ifdef __APPLE__
      /*
       * The Mac fcvt() returns "" when prec is 0, so we have to
       * compensate.  See bug 233530.
       * While it is conceivable that fcvt(round(d), 1) can return
       * a string that doesn't end in 0, it doesn't seem to happen
       * in practice (on the Mac).  The problematic case that we
       * want to avoid is a last digit greater than 4, which requires
       * rounding up, which we don't want to do, which is why we're
       * doing the rounding on the number instead of after fcvt()
       * in the first place.
       * -- edward
       */

      if (prec == 0) {
	 size_t l;
         pthread_mutex_lock(&mutex);
	 str = strdup(fcvt(round(d), 1, &dec, sign));
         pthread_mutex_unlock(&mutex);
	 if (str) {
	    l = strlen(str);
	    ASSERT(l > 0);
	    l--;
	    ASSERT(str[l] == '0');
	    str[l] = '\0';
         }
      } else 
#endif // __APPLE__
      {
         pthread_mutex_lock(&mutex);
         str = strdup(fcvt(d, prec, &dec, sign));
         pthread_mutex_unlock(&mutex);
      }
   }
#endif // _WIN32

   if (str) {
      *strEnd = str + strlen(str);

      /* strip trailing zeroes */
      while ((*strEnd > str) && ('0' == *((*strEnd) - 1))) {
         (*strEnd)--;
      }

      *expOut = dec;
   }

   return str;
}
Esempio n. 23
0
void runFailure() {
    fcvt(anydouble(), anyint(), NULL, NULL);
}
Esempio n. 24
0
void runSuccess() {
    int d,n;
    fcvt(anydouble(), anyint(), &d, &n);
}
Esempio n. 25
0
void
format (struct obstack *obs, int argc, token_data **argv)
{
#ifdef HAVE_EFGCVT

  const char *fmt;		/* format control string */
  int c;			/* a simple character */
  char fc;			/* format code */

  /* Flags.  */
  char flags;			/* 1 iff treating flags */
  char ljust;			/* left justification */
  char mandsign;		/* mandatory sign */
  char noplus;			/* use space if no sign */
  char alternate;		/* use alternate form */
  char zeropad;			/* do zero padding */
  char plus;			/* plus-sign, according to mandatory and noplus */

  /* Precision specifiers.  */
  int width;			/* minimum field width */
  int prec;			/* precision */
  int maxch;			/* maximum no. of chars to print */
  char lflag;			/* long flag */
  char hflag;			/* short flag */

  /* Different parts of each specification.  */
  char sign;			/* wanted sign, iff any */
  int ppad;			/* pre-prefix zero padding */
  const char *prefix;		/* value prefix */
  int lpad;			/* zero padding on the left */
  register char *s;		/* ptr to formatted text */
  int rpad;			/* zero padding on the rigth*/
  const char *suffix;		/* value suffix */

  /* Buffer and stuff.  */
  char str[MAXFIELD];		/* buffer for formatted text */
  int length;			/* length of str */
  int padding;			/* padding at the left or rigth */
  register int i;		/* an index */

/* Length of trailing string in str.  */
#define LENGTH(s)	(&str[MAXFIELD-1] - (s))
#define HAS_SIGN	(sign != '\0')

  fmt = ARG_STR (argc, argv);
  for (;;)
    {
      while ((c = *fmt++) != '%')
	{
	  if (c == 0)
	    return;
	  obstack_1grow (obs, c);
	}
      if (*fmt == '%')
	{
	  obstack_1grow (obs, '%');
	  fmt++;
	  continue;
	}

      /* Parse flags.  */
      flags = 1;
      ljust = mandsign = noplus = alternate = zeropad = 0;
      do
	{
	  switch (*fmt)
	    {
	    case '-':		/* left justification */
	      ljust = 1;
	      break;

	    case '+':		/* mandatory sign */
	      mandsign = 1;
	      break;

	    case ' ':		/* space instead of positive sign */
	      noplus = 1;
	      break;

	    case '0':		/* zero padding */
	      zeropad = 1;
	      break;

	    case '#':		/* alternate output */
	      alternate = 1;
	      break;

	    default:
	      flags = 0;
	      break;
	    }
	}
      while (flags && fmt++);

      plus = '\0';		/* what to use as a plus ??? */
      if (mandsign)
	plus = '+';
      else if (noplus)
	plus = ' ';

      if (ljust)
	zeropad = 0;

      /* Minimum field width.  */
      width = -1;
      if (*fmt == '*')
	{
	  width = ARG_INT (argc, argv);
	  fmt++;
	}
      else if (isdigit (*fmt))
	{
	  width = 0;
	  do
	    {
	      width = width * 10 + *fmt++ - '0';
	    }
	  while (isdigit (*fmt));
	}

      /* Maximum precision.  */
      prec = -1;
      if (*fmt == '.')
	{
	  if (*(++fmt) == '*')
	    {
	      prec = ARG_INT (argc, argv);
	      ++fmt;
	    }
	  else if (isdigit (*fmt))
	    {
	      prec = 0;
	      do
		{
		  prec = prec * 10 + *fmt++ - '0';
		}
	      while (isdigit (*fmt))
		;
	    }
	}

      /* Length modifiers.  */
      lflag = (*fmt == 'l');
      hflag = (*fmt == 'h');
      if (lflag || hflag)
	fmt++;

      sign = '\0';
      ppad = lpad = rpad = 0;
      maxch = -1;
      prefix = suffix = "";

      switch (fc = *fmt++)
	{

	case '\0':
	  return;

	case 'c':
	  c = ARG_INT (argc, argv);
	  str[0] = (unsigned char) c;
	  str[1] = '\0';
	  s = str;
	  break;

	case 's':
	  s = ARG_STR (argc, argv);
	  maxch = prec;
	  break;

	case 'd':
	case 'i':
	  if (lflag)
	    {
	      long val = ARG_LONG (argc, argv);
	      if (val < 0)
		{
		  val = -val;	/* does not work for MINLONG */
		  sign = '-';
		}
	      else
		sign = plus;
	      s = ulong_to_str ((unsigned long) val, str, 10, digits);
	    }
	  else
	    {
	      int val = ARG_INT (argc, argv);
	      if (hflag)
		val = (short) val;
	      if (val < 0)
		{
		  val = -val;	/* does not work for MININT */
		  sign = '-';
		}
	      else
		sign = plus;
	      s = ulong_to_str ((unsigned long) val, str, 10, digits);
	    }
	  if (zeropad)
	    lpad = width - LENGTH (s) - HAS_SIGN;
	  break;

	case 'o':
	  if (lflag)
	    {
	      unsigned long val = ARG_ULONG (argc, argv);
	      s = ulong_to_str ((unsigned long) val, str, 8, digits);
	    }
	  else
	    {
	      unsigned int val = ARG_UINT (argc, argv);
	      if (hflag)
		val = (unsigned short) val;
	      s = ulong_to_str ((unsigned long) val, str, 8, digits);
	    }
	  if (alternate)
	    prefix = "0";
	  if (zeropad)
	    lpad = width - LENGTH (s) - alternate;
	  break;

	case 'x':
	case 'X':
	  if (lflag)
	    {
	      unsigned long val = ARG_ULONG (argc, argv);
	      s = ulong_to_str ((unsigned long) val, str, 16,
			       (fc == 'x') ? digits : Digits);
	    }
	  else
	    {
	      unsigned int val = ARG_UINT (argc, argv);
	      if (hflag)
		val = (unsigned short) val;
	      s = ulong_to_str ((unsigned long) val, str, 16,
			       (fc == 'x') ? digits : Digits);
	    }
	  if (alternate)
	    prefix = (fc == 'X') ? "0X" : "0x";
	  if (zeropad)
	    lpad = width - LENGTH (s) - 2*alternate;
	  break;

	case 'u':
	  if (lflag)
	    {
	      unsigned long val = ARG_ULONG (argc, argv);
	      s = ulong_to_str ((unsigned long) val, str, 10, digits);
	    }
	  else
	    {
	      unsigned int val = ARG_UINT (argc, argv);
	      if (hflag)
		val = (unsigned short) val;
	      s = ulong_to_str ((unsigned long) val, str, 10, digits);
	    }
	  if (zeropad)
	    lpad = width - LENGTH (s);
	  break;

	case 'e':
	case 'E':
	  {
	    char *t;
	    int sgn, decpt, exp, n;
	    double val = ARG_DOUBLE (argc, argv);

	    if (prec < 0)
	      prec = 6;
	    t = clr0 (ecvt (val, min (prec + 1, ECVTMAX), &decpt, &sgn));
	    sign = sgn ? '-' : plus;

	    n = prec;
	    s = str;
	    exp = (t[0] == '0' && t[1] == '\0') ? 0 : decpt - 1;

	    *s++ = *t++;
	    if (n > 0 || alternate)
	      *s++ = '.';
	    while (*t != '\0' && --n >= 0)
	      *s++ = *t++;
	    *s = '\0';
	    rpad = n;

	    sgn = 0;
	    if (exp < 0)
	      {
		exp = -exp;
		sgn = 1;
	      }
	    t = ulong_to_str ((unsigned long) exp, str, 10, digits);
	    if (exp < 10)
	      *--t = '0';	/* always at least two digits */
	    *--t = sgn ? '-' : '+';
	    *--t = fc;

	    if (zeropad)
	      {
		lpad = width - HAS_SIGN - (s - str) - LENGTH (t);
		if (rpad > 0)
		  lpad -= rpad;
	      }

	    suffix = t;
	    s = str;
	  }
	  break;

	case 'f':
	  {
	    const char *t;
	    int sgn, decpt, n;
	    double val = ARG_DOUBLE (argc, argv);

	    if (prec < 0)
	      prec = 6;

	    /* FIXME: For the following line, Dave Anglin reports
	       ``warning: passing arg 1 of `clr0' discards `const' from
	       pointer target type''.  I suspect fcvt might be declared
	       as returning const on some systems.  Pouah!  I should
	       revise this whole module, one of these days...  */

	    t = clr0 (fcvt (val, min (prec, FCVTMAX), &decpt, &sgn));

	    sign = sgn ? '-' : plus;

	    n = prec;
	    s = str;

	    if (decpt <= 0)
	      {
		prefix = (n > 0 || alternate) ? "0." : "0";
		lpad = min (-decpt, prec);
		n -= lpad;
	      }
	    else
	      {
		while (--decpt >= 0)
		  *s++ = *t++;
		if (n > 0 || alternate)
		  *s++ = '.';
	      }
	    while (*t && --n >= 0)
	      *s++ = *t++;

	    *s = '\0';
	    rpad = n;

	    if (zeropad)
	      ppad = width - HAS_SIGN - (prefix[1] ? 2 : 1) - lpad -
		(s - str) - rpad;

	    s = str;
	  }
	  break;

	default:
	  continue;
	}

      if (lpad < 0)
	lpad = 0;
      if (rpad < 0)
	rpad = 0;
      if (width < 0)
	width = 0;

      i = strlen (s);
      if (maxch <= 0 || maxch > i)
	maxch = i;

      length = (HAS_SIGN + ppad + strlen (prefix) + lpad + maxch
		+ rpad + strlen (suffix));
      padding = 0;
      if (width != 0)
	{
	  padding = width - length;
	}

      if (ljust == 0)		/* left padding */
	for (i = padding; --i >= 0;)
	  obstack_1grow (obs, ' ');
      if (HAS_SIGN)		/* sign */
	obstack_1grow (obs, sign);
      for (i = ppad; --i >= 0;)	/* pre-prefix zero padding */
	obstack_1grow (obs, '0');
      for (; *prefix; ++prefix)	/* prefix */
	obstack_1grow (obs, *prefix);
      for (i = lpad; --i >= 0;)	/* left zero padding */
	obstack_1grow (obs, '0');
      for (i = maxch; --i >= 0; ++s) /* actual text */
	obstack_1grow (obs, *s);
      for (i = rpad; --i >= 0;)	/* right zero padding */
	obstack_1grow (obs, '0');
      for (; *suffix; ++suffix)	/* suffix */
	obstack_1grow (obs, *suffix);
      if (ljust != 0)		/* right padding */
	for (i = padding; --i >= 0;)
	  obstack_1grow (obs, ' ');
    }

#else /* not HAVE_EFGCVT */

  char *fmt;			/* format control string */
  const char *fstart;		/* beginning of current format spec */
  int c;			/* a simple character */

  /* Flags.  */
  char flags;			/* 1 iff treating flags */

  /* Precision specifiers.  */
  int width;			/* minimum field width */
  int prec;			/* precision */
  char lflag;			/* long flag */
  char hflag;			/* short flag */

  /* Buffer and stuff.  */
  char str[256];		/* buffer for formatted text */
  enum {INT, UINT, LONG, ULONG, DOUBLE, STR} datatype;

  fmt = ARG_STR (argc, argv);
  for (;;)
    {
      while ((c = *fmt++) != '%')
	{
	  if (c == 0)
	    return;
	  obstack_1grow (obs, c);
	}

      fstart = fmt - 1;

      if (*fmt == '%')
	{
	  obstack_1grow (obs, '%');
	  fmt++;
	  continue;
	}

      /* Parse flags.  */
      flags = 1;
      do
	{
	  switch (*fmt)
	    {
	    case '-':		/* left justification */
	    case '+':		/* mandatory sign */
	    case ' ':		/* space instead of positive sign */
	    case '0':		/* zero padding */
	    case '#':		/* alternate output */
	      break;

	    default:
	      flags = 0;
	      break;
	    }
	}
      while (flags && fmt++);

      /* Minimum field width.  */
      width = -1;
      if (*fmt == '*')
	{
	  width = ARG_INT (argc, argv);
	  fmt++;
	}
      else if (isdigit (*fmt))
	{
	  do
	    {
	      fmt++;
	    }
	  while (isdigit (*fmt));
	}

      /* Maximum precision.  */
      prec = -1;
      if (*fmt == '.')
	{
	  if (*(++fmt) == '*')
	    {
	      prec = ARG_INT (argc, argv);
	      ++fmt;
	    }
	  else if (isdigit (*fmt))
	    {
	      do
		{
		  fmt++;
		}
	      while (isdigit (*fmt));
	    }
	}

      /* Length modifiers.  */
      lflag = (*fmt == 'l');
      hflag = (*fmt == 'h');
      if (lflag || hflag)
	fmt++;

      switch (*fmt++)
	{

	case '\0':
	  return;

	case 'c':
	  datatype = INT;
	  break;

	case 's':
	  datatype = STR;
	  break;

	case 'd':
	case 'i':
	  if (lflag)
	    {
	      datatype = LONG;
	    }
	  else
	    {
	      datatype = INT;
	    }
	  break;

	case 'o':
	case 'x':
	case 'X':
	case 'u':
	  if (lflag)
	    {
	      datatype = ULONG;
	    }
	  else
	    {
	      datatype = UINT;
	    }
	  break;

	case 'e':
	case 'E':
	case 'f':
	  datatype = DOUBLE;
	  break;

	default:
	  continue;
	}

      c = *fmt;
      *fmt = '\0';

      switch(datatype) 
	{
	case INT:
	  if (width != -1 && prec != -1)
	    sprintf (str, fstart, width, prec, ARG_INT(argc, argv));
	  else if (width != -1)
	    sprintf (str, fstart, width, ARG_INT(argc, argv));
	  else if (prec != -1)
	    sprintf (str, fstart, prec, ARG_INT(argc, argv));
	  else
	    sprintf (str, fstart, ARG_INT(argc, argv));
	  break;

	case UINT:
	  if (width != -1 && prec != -1)
	    sprintf (str, fstart, width, prec, ARG_UINT(argc, argv));
	  else if (width != -1)
	    sprintf (str, fstart, width, ARG_UINT(argc, argv));
	  else if (prec != -1)
	    sprintf (str, fstart, prec, ARG_UINT(argc, argv));
	  else
	    sprintf (str, fstart, ARG_UINT(argc, argv));
	  break;

	case LONG:
	  if (width != -1 && prec != -1)
	    sprintf (str, fstart, width, prec, ARG_LONG(argc, argv));
	  else if (width != -1)
	    sprintf (str, fstart, width, ARG_LONG(argc, argv));
	  else if (prec != -1)
	    sprintf (str, fstart, prec, ARG_LONG(argc, argv));
	  else
	    sprintf (str, fstart, ARG_LONG(argc, argv));
	  break;

	case ULONG:
	  if (width != -1 && prec != -1)
	    sprintf (str, fstart, width, prec, ARG_ULONG(argc, argv));
	  else if (width != -1)
	    sprintf (str, fstart, width, ARG_ULONG(argc, argv));
	  else if (prec != -1)
	    sprintf (str, fstart, prec, ARG_ULONG(argc, argv));
	  else
	    sprintf (str, fstart, ARG_ULONG(argc, argv));
	  break;

	case DOUBLE:
	  if (width != -1 && prec != -1)
	    sprintf (str, fstart, width, prec, ARG_DOUBLE(argc, argv));
	  else if (width != -1)
	    sprintf (str, fstart, width, ARG_DOUBLE(argc, argv));
	  else if (prec != -1)
	    sprintf (str, fstart, prec, ARG_DOUBLE(argc, argv));
	  else
	    sprintf (str, fstart, ARG_DOUBLE(argc, argv));
	  break;

	case STR:
	  if (width != -1 && prec != -1)
	    sprintf (str, fstart, width, prec, ARG_STR(argc, argv));
	  else if (width != -1)
	    sprintf (str, fstart, width, ARG_STR(argc, argv));
	  else if (prec != -1)
	    sprintf (str, fstart, prec, ARG_STR(argc, argv));
	  else
	    sprintf (str, fstart, ARG_STR(argc, argv));
	  break;
	}

      *fmt = c;

      obstack_grow (obs, str, strlen (str));
    }

#endif /* not HAVE_EFGCVT */
}
Esempio n. 26
0
//---------- Begin of function Misc::format --------//
//
// Format a number to a float number to format string
// Note : the formated string is right justified
//
// <double> inNum = the number to be formated
//                  use <double> instead of <float> because
//                  fcvt() only accept <double>
//
// [int] formatType = 1 - 1,000,000  add thousand seperator
//                    2 - $1,000,000 add thousand seperator and dollar sign
//                    3 - 56% add percentage sign % at the end of the number
//
// return <char*> the pointer to the converted string, the string
//                is stored in static variable which will be overwritten
//                in next call.
//
char* Misc::format(double inNum, int formatType)
{
   enum { MONEY_DEC_PLACE = 2 };

   static char outBuf[35];
   char   *outPtr=outBuf;
   char   *floatStr;
   int    i, intDigit, sign;    // intDigit = no. of integer digits

   floatStr = fcvt( inNum, MONEY_DEC_PLACE, &intDigit, &sign );

   #ifdef DEBUG
      if( intDigit > 29 )            // integer digits can't exceed 29
         err.run( "Misc::format(), inNum : %e, formatType : %d", inNum, formatType );
   #endif

   //--------- negetive bracket ------------//

   if( inNum < 0 )
      *outPtr++ = '(';

   //--------- dollar sign ($) ------------//

   if( formatType == 2 )
      *outPtr++ = '$';

   //------- integer number -----------//

   for( i=intDigit ; i>0 ; i-- )
   {
      if( i%THOUSAND_SEPARATOR_COUNT == 0 && i < intDigit )
         *outPtr++ = THOUSAND_SEPARATOR;

      *outPtr++ = *floatStr++;
   }

   if( intDigit <= 0 )
      *outPtr++ = '0';

   //------- dec. place number -----------//

   if( inNum > -1000 && inNum < 1000 )    // if the number is less than 1000, add dec. places
   {                                      // if the number is greater than 1000, truncate any dec. places
      *outPtr++ = DECIMAL_SEPARATOR;

      if( *floatStr && intDigit >= 0 )    // e.g. 0.03 --> str:"3", intDight:-1
         *outPtr++ = *floatStr++;         // 1st dec. place
      else
         *outPtr++ = '0';                 // add a '0' when intDigit < 0

      if( *floatStr )                     // 2nd dec. place
         *outPtr++ = *floatStr++;
      else
         *outPtr++ = '0';
   }

   //--------- percent sign (%) ------------//

   if( formatType == 3 )
      *outPtr++ = '%';

   //--------- negetive bracket ------------//

   if( inNum < 0 )
      *outPtr++ = ')';

   *outPtr++ = '\0';

   return outBuf;
}
Esempio n. 27
0
 inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf)
   { return fcvt(x, n, pt, sign); }
Esempio n. 28
0
void mc_fstr(double valeur, int signe, int nbint, int nbfrac,int zeros,char *chaine)
/***************************************************************************/
/* Formatage d'une chaine de sortie a partir d'une valeur numerique.       */
/***************************************************************************/
/* valeur : valeur numerique a formater                                    */
/* signe : =OK pour ajouter + ou - devant la chaine                        */
/*         =PBB pour ajouter ' ' ou - devant la chaine                     */
/*         =PB pour la valeur absolue                                      */
/* nbint : nombre de chiffres pour la partie entiere                       */
/* nbfrac : nombre de chiffres pour la partie decimale                     */
/* zeros  : =OK pour laisser les zeros devant sinon (=PB) des espaces      */
/***************************************************************************/
{
   double v,vint,vfrac,cstint,cstfrac;
   int s,dec,lon,k,ssigne;
   char chaines[3],chaine1[84],chaine2[84],chaine3[84],chainezero[84];

   /*--- test de depassement de chaine ---*/
   memset(chaine3,'-',83);chaine3[83]='\0';
   lon=0;
   if (signe==1) {
      lon+=1;
   }
   if (nbfrac>0) {
      lon+=1;
   }
   lon+=(nbint+nbfrac);
   if (lon>(int)(strlen(chaine3))) {
      memset(chaine3,'-',strlen(chaine3));chaine3[strlen(chaine3)]='\0';
      strcpy(chaine,chaine3);
      return;
   }

   /*--- constantes multiplicatives pour les parties entieres et decimales */
   cstint =pow(10,nbint ) ;
   cstfrac=pow(10,nbfrac) ;

   /*--- on traite le signe ---*/
   s=(int) (mc_sgn(valeur));
   if (signe==OK) {
      if (s>=0) { strcpy(chaines,"+"); } else { strcpy(chaines,"-"); }
   } else if (signe==PBB) {
      if (s>=0) { strcpy(chaines," "); } else { strcpy(chaines,"-"); }
   } else {
      strcpy(chaines,"");
   }

   /*--- on arondit la valeur tronquee ---*/
   v=fabs(valeur);
   vfrac=mc_frac(v*cstfrac);
   vint=floor(v*cstfrac);
   if (vfrac>=.5) {
      v=(vint+1.)/cstfrac;
   }

   /*--- on traite la partie entiere ---*/
   vint=floor(v);
   if (vint>=cstint) {
      vint=cstint-1;
   }
   vint+=cstint;
   strcpy(chaine1,fcvt(vint,nbint+2,&dec,&ssigne)+1);
   *(chaine1+nbint)='\0';
   if ((nbint>1)&&(zeros==PB)) {
      for (k=1;k<=nbint-1;k++) {
         if (chaine1[k-1]=='0') {
            if (signe==PB) {
               chaine1[k-1]=' ';
            } else {
               if (k==1) {
                  chaine1[k-1]=chaines[0];
                  chaines[0]=' ';
               } else {
                  chaine1[k-1]=chaine1[k-2];
                  chaine1[k-2]=' ';
               }
            }
         } else {
            break;
         }
      }
   }

   /*--- on traite la partie decimale ---*/
   if (nbfrac==0) {
      strcpy(chaine2,"");
   } else {
      vfrac=cstfrac+floor(mc_frac(v)*(cstfrac+.1));
      strcpy(chaine2,fcvt(vfrac,nbfrac+2,&dec,&ssigne)+1);
      memset(chainezero,'0',nbfrac);chainezero[nbfrac]='\0';
      strcat(chaine2,chainezero);
      *(chaine2+nbfrac)='\0';
   }

   /*--- creation de la chaine de sortie formatee ---*/
   strcpy(chaine3,chaines);
   strcat(chaine3,chaine1);
   if (nbfrac>0) {
      strcat(chaine3,".");
      strcat(chaine3,chaine2);
   }
   strcpy(chaine,chaine3);
   return;
}
Esempio n. 29
0
char * _RTL_FUNC _fcvt(double val, int len, int *decimal, int *sign)
{
    return fcvt(val, len, decimal, sign);
}
Esempio n. 30
0
//start of main
void main()
{
//getch();
  initialize();      //initialises graphics mode
  setcolor(RED);     //sets text color red
  mainscreen();      //draws format for calculator
  mouse m;           //creates mouse object
  char string[100];
  int button,xx,yy,flag=0,index,i;
  int counter;
  int matrix[5][3]={{0,1,2},{3,4,5},{6,7,8},{9,10,11},{12,13,14}};
  int count=0;
  //setviewport(70,70,getmaxx()-80,100,1);
  //clearviewport();
  long double num[100],ii=0,rcount=0;
  drawscreen();         //creates output screen
  while(1)
  {


  counter=150;
  button=0;
  m.getmousepos(button,xx,yy);        //gets x&y position of mouse ptr

  if(((button & 1)==1)&&(flag==0))
    {
	for(int k=0;k<5;k++)
		{
		for(int x=400,i=0;x<=5*100;x+=50,i++)
			{
			if(xx>=x && xx<=x+30 && yy>=counter&&yy<=counter+20)
				{
				index=matrix[k][i];
				flag=1;
				//cout<<index;
				//delay(200);
				goto end;
				}
			}
		   counter+=40;
		}

    }

    end:
    //(430,350,500,375);
    if(((button & 1)==1)&&(flag==0))
    {
    if(xx>=430&&xx<=500&&yy>=350&&yy<=375)
    index=50;
    flag=1;
    }
    switch(index)
    {



    case 50:
	m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	 exit(0);
	}

    case 0:

	m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	//setcolor(WHITE);
       drawscreen();
	setcolor(WHITE);


	string[count]='9';
	num[ii]=9;
	ii++;
	//outtextxy(getmaxx()-(5*count+200),70,string);

	count++;
	string[count]='\0';
	outtextxy(getmaxx()-(200+5*count),70,string );
	//delay(0);
	flag=0;
	}
	break;

    case 1:

	m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	//setcolor(WHITE);
	drawscreen();
	setcolor(WHITE);
	//outtextxy(getmaxx()-100,70,"8" );


	string[count]='8';
	count++;
	string[count]='\0';
		num[ii]=8;
	ii++;
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 2:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);
	//outtextxy(getmaxx()-100,70,"7" );
	string[count]='7';
	count++;
	string[count]='\0';
		num[ii]=7;
	ii++;
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 3:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);
	//outtextxy(getmaxx()-100,70,"6" );
	string[count]='6';
	count++;
	string[count]='\0';
		num[ii]=6;
	ii++;
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 4:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);
       //	outtextxy(getmaxx()-100,70,"5" );
       string[count]='5';
	count++;
	string[count]='\0';
		num[ii]=5;
	ii++;
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 5:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);
	//outtextxy(getmaxx()-100,70,"4" );
	string[count]='4';
	count++;
	string[count]='\0';
		num[ii]=4;
	ii++;
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 6:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);
	//outtextxy(getmaxx()-100,70,"3" );
	string[count]='3';
	count++;
	string[count]='\0';
		num[ii]=3;
	ii++;
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 7:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);
	//+outtextxy(getmaxx()-100,70,"2" );
	string[count]='2';
	count++;
	string[count]='\0';
		num[ii]=2;
	ii++;
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 8:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);
	//outtextxy(getmaxx()-100,70,"1" );
	string[count]='1';
	count++;
	string[count]='\0';
		num[ii]=1;
	ii++;
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 9:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);
	//outtextxy(getmaxx()-100,70,"0" );
	string[count]='0';
	count++;
	string[count]='\0';
		num[ii]=0;
	ii++;
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 10:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);
	//outtextxy(getmaxx()-100,70,"+" );
	string[count]='+';
	count++;
	string[count]='\0';
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 11:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);
	//outtextxy(getmaxx()-100,70,"-" );
	string[count]='-';
	count++;
	string[count]='\0';
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 12:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	clearscreen();

	setcolor(WHITE);
	//string[count]='/';
	//count++;
	//outtextxy(getmaxx()-100,70,"%" );
       //	string[count]='\0';
   //	outtextxy(getmaxx()-(200+5*count),70,string );
	count=0;
	flag=0;
	}
	break;
    case 13:
	  m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{
	drawscreen();
	setcolor(WHITE);

	string[count]='*';
	count++;
	string[count]='\0';
	outtextxy(getmaxx()-(200+5*count),70,string );
	flag=0;
	}
	break;
    case 14:
	char s1[100],s2[100];
	char * s11,s22;
	long double value=0;

	long double n1=0,n2=0;
	m.getmousepos(button,xx,yy);
	if(((button & 1)==0) && (flag==1))
	{

	drawscreen();
	setcolor(WHITE);


	for(int k=0;k<count;k++)
	{
	if(string[k]=='+'||string[k]=='-'||string[k]=='*'||string[k]=='-')
	{
	for(int p=0,q=k-1;p<k;p++,q--)
	{
	n1+=(num[p]*(pow(10,q)));

	}

	for(p=k,q=(ii-k-1);p<count-1;p++,q--)
	{

	 n2+=(num[p]*(pow(10,q)));

	}
	if(string[k]=='+')
	{
	value=(double)(n1+n2);

	break;
	}
	if(string[k]=='-')
	{
	value=(double)(n1-n2);
	break;
	}
	if(string[k]=='*')
	{
	value=(double)(n1*n2);
	break;
	}
       /*	if(string[k]=='cls')
	{
	value=(double)(n1/n2);
	break;
	}*/
	}
	}

	int ndig=0,dec,sign;
	s11 = fcvt(value,ndig, &dec, &sign);//converts a num into string
       drawscreen();
       setcolor(WHITE);
	outtextxy(getmaxx()-(5*strlen(s11)+200),70,s11);
	rcount++;
	flag=0;
	count=0;

	ii=0;
	}
	break;

    }

  }
  //getch();
  restorecrtmode();       //restores textmode
}