uts/sprintf_wrap.c

   1 #include        <stdlib.h>
   2 #include        <stdio.h>
   3 #include        <assert.h>
   4 #include        <string.h>
   5
   6 char    *UTS_sprintf_wrap();
   7 char    *do_efmt();
   8 char    *do_gfmt();
   9 char    *Fill();
  10
  11 /* main(argc, argv)
  12  * char **argv;
  13  * {
  14  *      double  d;
  15  *      char    *Fmt, *Ret;
  16  *      char    obuf[200];
  17  *
  18  *      assert(argc > 2);
  19  *      Fmt = argv[1];
  20  *      d = strtod(argv[2], (char **)0);
  21  *
  22  *      putchar('{');
  23  *      printf(Fmt, d);
  24  *      printf("}\n");
  25  *
  26  *      Ret = UTS_sprintf_wrap(obuf, Fmt, d);
  27  *      assert(Ret == obuf);
  28  *
  29  *      printf("{%s}\n", obuf);
  30  * }
  31  */
  32
  33 char *
  34 UTS_sprintf_wrap(obuf, fmt, d,
  35         a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15)
  36 char    *obuf, *fmt;
  37 double  d;
  38 {
  39         int     fmtlen, Width=0, Precision=6, Alt=0, Plus=0, Minus=0,
  40                 Zero = 0;
  41         int     FmtChar, BaseFmt = 0;
  42         char    *f = fmt, *AfterWidth = 0, *AfterPrecision = 0;
  43         char    *Dot;
  44
  45         if(*f++ != '%') {
  46                 return
  47 sprintf(obuf, fmt, d, a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15);
  48         }
  49         fmtlen = strlen(fmt);
  50         FmtChar = fmt[fmtlen - 1];
  51         switch(FmtChar) {
  52         case 'f':
  53         case 'F':
  54                 return
  55 sprintf(obuf, fmt, d, a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15);
  56         case 'e':
  57         case 'E':
  58                 BaseFmt = 'e';
  59                 goto BaseFmt_IsSet;
  60         case 'g':
  61         case 'G':
  62                 BaseFmt = 'g';
  63 BaseFmt_IsSet:
  64                 if(*f == '#') { Alt = 1; ++f; }   /* Always has '.' */
  65                 if(*f == '+') { Plus = 1; ++f; }  /* Force explicit sign */
  66                 if(*f == '-') { Minus = 1; ++f; } /* Left justify */
  67                 if(*f == '0') { Zero = 1; ++f;} /* Fill using 0s*/
  68                 if(Dot = strchr(f, '.')) {
  69                         Precision = strtol(Dot+1, &AfterPrecision, 0);
  70                 }
  71                 if(!Dot || (Dot && Dot > f)) { /* Next char=='.' => no width*/
  72                         Width = strtol(f, &AfterWidth, 0);
  73                 }
  74                 if(Dot) { f = AfterPrecision; }
  75                 else if(AfterWidth) { f = AfterWidth; }
  76                 if(*f != FmtChar) goto regular_sprintf;
  77                  /* It doesn't look like a f.p. sprintf call */
  78                  /* from Perl_sv_vcatpvfn                    */
  79
  80                 if(BaseFmt == 'e') {
  81                         return do_efmt(d, obuf, Width, Precision, Alt,
  82                                 Plus, Minus, Zero, FmtChar == 'E');
  83                 } else {
  84                         return do_gfmt(d, obuf, Width, Precision, Alt,
  85                                 Plus, Minus, Zero, FmtChar == 'G');
  86                 }
  87         default:
  88 regular_sprintf:
  89                 return
  90 sprintf(obuf, fmt, d, a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15);
  91         }
  92 }
  93
  94 char    *
  95 do_efmt(d, obuf, Width, Precision, Alt, Plus, Minus, Zero, UpperCase)
  96 char    *obuf;
  97 double  d;
  98 {
  99         char    *Ecvt;
 100         char    *ob;
 101         int     decpt, sign, E;
 102         int     len;
 103         int     AllZeroes = 0;
 104
 105         Ecvt = ecvt( d , Precision+1, &decpt, &sign);
 106
 107         /* fprintf(stderr, "decpt=%d, sign=%d\n", decpt, sign); */
 108
 109         len = strlen(Ecvt);
 110         if(strspn(Ecvt, "0") == len) AllZeroes = 1;
 111
 112         ob = obuf;
 113         if(sign)        *ob++ = '-';
 114         else if(Plus)   *ob++ = '+';
 115
 116         *ob++ = Ecvt[0];
 117
 118         if(Precision > 0 || Alt) *ob++ = '.';
 119         strcpy(ob, &Ecvt[1]);
 120
 121         ob += strlen(ob);       /* ADVANCE TO END OF WHAT WE JUST ADDED */
 122         *ob++ = UpperCase ? 'E' : 'e';
 123
 124         if(AllZeroes)   E = 0;
 125         else            E = decpt - 1;
 126
 127         if(E < 0)       { *ob++ = '-'; E = -E; }
 128         else            { *ob++ = '+'; }
 129
 130         sprintf(ob, "%.2d", E); /* Too much horsepower used here */
 131
 132         if(Width > strlen(obuf)) return Fill(obuf, Width, Minus, Zero);
 133         else                     return obuf;
 134 }
 135
 136 char    *
 137 do_gfmt(d, obuf, Width, Precision, Alt, Plus, Minus, Zero, UpperCase)
 138 char    *obuf;
 139 double  d;
 140 {
 141         char    *Ecvt = gcvt(d, Precision ? Precision : 1, obuf);
 142         int     len = strlen(obuf);
 143
 144          /* gcvt fails (maybe give a warning? For now return empty string): */
 145         if(!Ecvt) { *obuf = '\0'; return obuf; }
 146
 147         /* printf("Ecvt='%s'\n", Ecvt); */
 148         if(Plus && (Ecvt[0] != '-')) {
 149                 memmove(obuf+1, obuf, len+1); /* "+1" to get '\0' at end */
 150                 obuf[0] = '+';
 151                 ++len;
 152         }
 153         if(Alt && !strchr(Ecvt, '.')) {
 154                 int     LenUpTo_E = strcspn(obuf, "eE");
 155                 int     E_etc_len = strlen(&obuf[LenUpTo_E]);
 156                         /* ABOVE: Will be 0 if there's no E/e because */
 157                         /* strcspn will return length of whole string */
 158
 159                 if(E_etc_len)
 160                         memmove(obuf+LenUpTo_E+1, obuf+LenUpTo_E, E_etc_len);
 161                 obuf[LenUpTo_E] = '.';
 162                 obuf[LenUpTo_E + 1 + E_etc_len ] = '\0';
 163         }
 164         { char *E_loc;
 165           if(UpperCase && (E_loc = strchr(obuf, 'e'))) { *E_loc = 'E'; }
 166         }
 167         if(Width > len)
 168                 return Fill(obuf, Width, Minus, Zero);
 169         else
 170                 return obuf;
 171 }
 172
 173 char *
 174 Fill(obuf, Width, LeftJustify, Zero)
 175 char    *obuf;
 176 {
 177         int     W = strlen(obuf);
 178         int     diff = Width - W;
 179          /* LeftJustify means there was a '-' flag, and in that case,   */
 180          /* printf man page (UTS4.4) says ignore '0'                    */
 181         char    FillChar = (Zero && !LeftJustify) ? '0' : ' ';
 182         int     i;
 183         int     LeftFill = ! LeftJustify;
 184
 185         if(Width <= W) return obuf;
 186
 187         if(LeftFill) {
 188                 memmove(obuf+diff, obuf, W+1); /* "+1" to get '\0' at end */
 189                 for(i=0 ; i < diff ; ++i) { obuf[i] = FillChar; }
 190         } else {
 191                 for(i=W ; i < Width ; ++i)
 192                         obuf[i] = FillChar;
 193                 obuf[Width] = '\0';
 194         }
 195         return obuf;
 196 }