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