home *** CD-ROM | disk | FTP | other *** search
/ Aminet 4 / Aminet 4 - November 1994.iso / aminet / dev / gcc / libnix.lha / gnu / lib / libnix / sources.lha / nix / stdio / vfprintf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-12  |  10.6 KB  |  378 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdarg.h>
  4. #include <limits.h>
  5. #include <ctype.h>
  6. #include <stabs.h>
  7. #include <math.h>
  8. #include <float.h>
  9. #include <strsup.h>
  10.  
  11. /* a little macro to make life easier */
  12.  
  13. #define OUT(c)  do                           \
  14.                 { if(fputc((c),stream)==EOF) \
  15.                     return outcount;         \
  16.                   outcount++;                \
  17.                 }while(0)
  18.  
  19. #define MINFLOATSIZE (sizeof(double)*BITSPERBYTE*302/1000+1)
  20. #define MININTSIZE (sizeof(unsigned long)*BITSPERBYTE/3+1)
  21. #define MINPOINTSIZE (sizeof(void *)*BITSPERBYTE/4+1)
  22. #define REQUIREDBUFFER (MININTSIZE>MINPOINTSIZE? \
  23.                         (MININTSIZE>MINFLOATSIZE?MININTSIZE:MINFLOATSIZE): \
  24.                         (MINPOINTSIZE>MINFLOATSIZE?MINPOINTSIZE:MINFLOATSIZE))
  25.  
  26. #define ALTERNATEFLAG 1  /* '#' is set */
  27. #define ZEROPADFLAG   2  /* '0' is set */
  28. #define LALIGNFLAG    4  /* '-' is set */
  29. #define BLANKFLAG     8  /* ' ' is set */
  30. #define SIGNFLAG      16 /* '+' is set */
  31.  
  32. extern unsigned char *__decimalpoint;
  33. extern unsigned char __undef[][sizeof(double)];
  34.  
  35. int vfprintf(FILE *stream,const char *format,va_list args)
  36. { 
  37.   size_t outcount=0;
  38.  
  39.   while(*format)
  40.   {
  41.     if(*format=='%')
  42.     { 
  43.       static char flagc[]=
  44.       { '#','0','-',' ','+' };
  45.       static char lowertabel[]=
  46.       { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f' };
  47.       static char uppertabel[]=
  48.       { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };
  49.       size_t width=0,preci=ULONG_MAX,flags=0; /* Specifications */
  50.       char type,subtype='i';
  51.       char buffer1[2];             /* Signs and that like */
  52.       char buffer[REQUIREDBUFFER]; /* The body */
  53.       char *buffer2=buffer;        /* So we can set this to any other strings */
  54.       size_t size1=0,size2=0;      /* How many chars in buffer? */
  55.       const char *ptr=format+1;    /* pointer to format string */
  56.       size_t i,pad;                /* Some temporary variables */
  57.  
  58.       do /* read flags */
  59.         for(i=0;i<sizeof(flagc);i++)
  60.           if(flagc[i]==*ptr)
  61.           { flags|=1<<i;
  62.             ptr++;
  63.             break; }
  64.       while(i<sizeof(flagc));
  65.  
  66.       if(*ptr=='*') /* read width from arguments */
  67.       { signed int a;
  68.         ptr++;
  69.         a=va_arg(args,signed int);
  70.         if(a<0)
  71.         { flags|=LALIGNFLAG;
  72.           width=-a; }
  73.         else
  74.           width=a;
  75.       }else
  76.         while(isdigit(*ptr))
  77.           width=width*10+(*ptr++-'0');
  78.  
  79.       if(*ptr=='.')
  80.       { ptr++;
  81.         if(*ptr=='*') /* read precision from arguments */
  82.         { signed int a;
  83.           ptr++;
  84.           a=va_arg(args,signed int);
  85.           if(a>=0)
  86.             preci=a;
  87.         }else
  88.         { preci=0;
  89.           while(isdigit(*ptr))
  90.             preci=preci*10+(*ptr++-'0');
  91.         }
  92.       }
  93.  
  94.       if(*ptr=='h'||*ptr=='l'||*ptr=='L')
  95.         subtype=*ptr++;
  96.  
  97.       type=*ptr++;
  98.  
  99.       switch(type)
  100.       { case 'd':
  101.         case 'i':
  102.         case 'o':
  103.         case 'p':
  104.         case 'u':
  105.         case 'x':
  106.         case 'X':
  107.         { unsigned long v;
  108.           char *tabel;
  109.           int base;
  110.  
  111.           if(type=='p')
  112.           { subtype='l'; /* This is written as %#lx */
  113.             type='x';
  114.             flags|=ALTERNATEFLAG; }
  115.  
  116.           if(type=='d'||type=='i') /* These are signed */
  117.           { signed long v2;
  118.             if(subtype=='l')
  119.               v2=va_arg(args,signed long);
  120.             else
  121.               v2=va_arg(args,signed int);
  122.             if(v2<0)
  123.             { buffer1[size1++]='-';
  124.               v=-v2;
  125.             }else
  126.             { if(flags&SIGNFLAG)
  127.                 buffer1[size1++]='+';
  128.               else if(flags&BLANKFLAG)
  129.                 buffer1[size1++]=' ';
  130.               v=v2; }
  131.           }else                    /* These are unsigned */
  132.           { if(subtype=='l')
  133.               v=va_arg(args,unsigned long);
  134.             else
  135.               v=va_arg(args,unsigned int);
  136.             if(flags&ALTERNATEFLAG)
  137.             { if(type=='o'&&(preci||v))
  138.                 buffer1[size1++]='0';
  139.               if((type=='x'||type=='X')&&v)
  140.               { buffer1[size1++]='0';
  141.                 buffer1[size1++]=type; }
  142.             }
  143.           }
  144.  
  145.           buffer2=&buffer[sizeof(buffer)]; /* Calculate body string */
  146.           base=type=='x'||type=='X'?16:(type=='o'?8:10);
  147.           tabel=type!='X'?lowertabel:uppertabel;
  148.           do
  149.           { *--buffer2=tabel[v%base];
  150.             v=v/base;
  151.             size2++;
  152.           }while(v);
  153.           if(preci==ULONG_MAX) /* default */
  154.             preci=0;
  155.           else
  156.             flags&=~ZEROPADFLAG;
  157.           break;
  158.         }
  159.         case 'c':
  160.           if(subtype=='l')
  161.             *buffer2=va_arg(args,long);
  162.           else
  163.             *buffer2=va_arg(args,int);
  164.           size2=1;
  165.           preci=0;
  166.           break;
  167.         case 's':
  168.           buffer2=va_arg(args,char *);
  169.           size2=strlen(buffer2);
  170.           size2=size2<=preci?size2:preci;
  171.           preci=0;
  172.           break;
  173. #ifdef FULL_SPECIFIERS
  174.         case 'f':
  175.         case 'e':
  176.         case 'E':
  177.         case 'g':
  178.         case 'G':
  179.         { double v;
  180.           char killzeros=0,sign=0; /* some flags */
  181.           int ex1,ex2; /* Some temporary variables */
  182.           size_t size,dnum,dreq;
  183.           char *udstr=NULL;
  184.  
  185.           v=va_arg(args,double);
  186.  
  187.           if(v==*(double *)&__undef[0])
  188.             udstr="+inf";
  189.           else if(v==*(double *)&__undef[1])
  190.             udstr="-inf";
  191.           else if(v==*(double *)&__undef[2])
  192.             udstr="NaN";
  193.  
  194.           if(udstr!=NULL)
  195.           { size2=strlen(udstr);
  196.             preci=0;
  197.             buffer2=udstr;
  198.             break; }
  199.  
  200.           if(preci==ULONG_MAX) /* old default */
  201.             preci=6; /* new default */
  202.  
  203.           if(v<0.0)
  204.           { sign='-';
  205.             v=-v;
  206.           }else
  207.           { if(flags&SIGNFLAG)
  208.               sign='+';
  209.             else if(flags&BLANKFLAG)
  210.               sign=' ';
  211.           }
  212.  
  213.           ex1=0;
  214.           if(v!=0.0)
  215.           { ex1=log10(v);
  216.             v=v/pow(10,ex1);
  217.             if(v<1.0) /* adjust if we are too low (log10(.1)=-.999999999) */
  218.             { v*=10.0; /* luckily this cannot happen with FLT_MAX and FLT_MIN */
  219.               ex1--; } /* The case too high (log(10.)=.999999999) is done later */
  220.           }
  221.  
  222.           ex2=preci;
  223.           if(type=='f')
  224.             ex2+=ex1;
  225.           if(tolower(type)=='g')
  226.           { if(ex1<(signed long)preci&&ex1>=-4)
  227.               ex2+=ex1;
  228.             ex2--; /* This is somehow strange, but ANSI requires it */
  229.           }
  230.           v+=.5*pow(.1,ex2); /* Round up */
  231.  
  232.           if(v>=10.0) /* Adjusts log10(10.)=.999999999 too */
  233.           { v/=10.0;
  234.             ex1++; }
  235.  
  236.           if(tolower(type)=='g') /* This changes to one of the other types */
  237.           { if(ex1<(signed long)preci&&ex1>=-4)
  238.               type='f';
  239.             else
  240.               type=type=='g'?'e':'E';
  241.             preci--;   /* Don't know why ANSI does this! */
  242.             if(!(flags&ALTERNATEFLAG))
  243.               killzeros=1; /* set flag to kill trailing zeros */
  244.           }
  245.  
  246.           dreq=preci+1; /* Calculate number of decimal places required */
  247.           if(type=='f')
  248.             dreq+=ex1;   /* even more before the decimal point */
  249.  
  250.           dnum=0;
  251.           while(dnum<dreq&&dnum<MINFLOATSIZE) /* Calculate all decimal places needed */
  252.           { buffer[dnum++]=(char)v+'0';
  253.             v=(v-(double)(char)v)*10.0; }
  254.  
  255.           if(killzeros) /* Kill trailing zeros if possible */
  256.             while(preci&&(dreq-->dnum||buffer[dreq]=='0'))
  257.               preci--;
  258.  
  259.           if(type=='f')/* Calculate actual size of string (without sign) */
  260.           { size=preci+1; /* numbers after decimal point + 1 before */
  261.             if(ex1>0)
  262.               size+=ex1; /* numbers >= 10 */
  263.             if(preci||flags&ALTERNATEFLAG)
  264.               size++; /* 1 for decimal point */
  265.           }else
  266.           { size=preci+5; /* 1 for the number before the decimal point, and 4 for the exponent */
  267.             if(preci||flags&ALTERNATEFLAG)
  268.               size++;
  269.             if(ex1>99||ex1<-99)
  270.               size++; /* exponent needs an extra decimal place */
  271.           }
  272.  
  273.           pad=size+(sign!=0);
  274.           pad=pad>=width?0:width-pad;
  275.  
  276.           if(sign&&flags&ZEROPADFLAG)
  277.             OUT(sign);
  278.  
  279.           if(!(flags&LALIGNFLAG))
  280.             for(i=0;i<pad;i++)
  281.               OUT(flags&ZEROPADFLAG?'0':' ');
  282.  
  283.           if(sign&&!(flags&ZEROPADFLAG))
  284.             OUT(sign);
  285.  
  286.           dreq=0;
  287.           if(type=='f')
  288.           { if(ex1<0)
  289.               OUT('0');
  290.             else
  291.               while(ex1>=0)
  292.               { OUT(dreq<dnum?buffer[dreq++]:'0');
  293.                 ex1--; }
  294.             if(preci||flags&ALTERNATEFLAG)
  295.             { OUT(__decimalpoint[0]);
  296.               while(preci--)
  297.                 if(++ex1<0)
  298.                   OUT('0');
  299.                 else
  300.                   OUT(dreq<dnum?buffer[dreq++]:'0');
  301.             }
  302.           }else
  303.           { OUT(buffer[dreq++]);
  304.             if(preci||flags&ALTERNATEFLAG)
  305.             { OUT(__decimalpoint[0]);
  306.               while(preci--)
  307.                 OUT(dreq<dnum?buffer[dreq++]:'0');
  308.             }
  309.             OUT(type);
  310.             if(ex1<0)
  311.             { OUT('-');
  312.               ex1=-ex1; }
  313.             else
  314.               OUT('+');
  315.             if(ex1>99)
  316.               OUT(ex1/100+'0');
  317.             OUT(ex1/10%10+'0');
  318.             OUT(ex1%10+'0');
  319.           }
  320.  
  321.           if(flags&LALIGNFLAG)
  322.             for(i=0;i<pad;i++)
  323.               OUT(' ');
  324.  
  325.           width=preci=0; /* Everything already done */
  326.           break;
  327.         }
  328. #endif
  329.         case '%':
  330.           buffer2="%";
  331.           size2=1;
  332.           preci=0;
  333.           break;
  334.         case 'n':
  335.           *va_arg(args,int *)=outcount;
  336.           width=preci=0;
  337.           break;
  338.         default:
  339.           if(!type)
  340.             ptr--; /* We've gone too far - step one back */
  341.           buffer2=(char *)format;
  342.           size2=ptr-format;
  343.           width=preci=0;
  344.           break;
  345.       }
  346.       pad=size1+(size2>=preci?size2:preci); /* Calculate the number of characters */
  347.       pad=pad>=width?0:width-pad; /* and the number of resulting pad bytes */
  348.  
  349.       if(flags&ZEROPADFLAG) /* print sign and that like */
  350.         for(i=0;i<size1;i++)
  351.           OUT(buffer1[i]);
  352.  
  353.       if(!(flags&LALIGNFLAG)) /* Pad left */
  354.         for(i=0;i<pad;i++)
  355.           OUT(flags&ZEROPADFLAG?'0':' ');
  356.  
  357.       if(!(flags&ZEROPADFLAG)) /* print sign if not zero padded */
  358.         for(i=0;i<size1;i++)
  359.           OUT(buffer1[i]);
  360.  
  361.       for(i=size2;i<preci;i++) /* extend to precision */
  362.         OUT('0');
  363.  
  364.       for(i=0;i<size2;i++) /* print body */
  365.         OUT(buffer2[i]);
  366.  
  367.       if(flags&LALIGNFLAG) /* Pad right */
  368.         for(i=0;i<pad;i++)
  369.           OUT(' ');
  370.  
  371.       format=ptr;
  372.     }
  373.     else
  374.       OUT(*format++);
  375.   }
  376.   return outcount;
  377. }
  378.