Return to vsprintf.c CVS log

Up to [DOOM] / doom

Annotation of doom/vsprintf.c, revision 1.1.1.1

1.1       root        1: #include "doomdef.h"
                      2: 
                      3: /* prints number of characters printed. */
                      4: 
                      5: int mystrlen(char *string)
                      6: {
                      7:   int rc = 0;
                      8:   if (string) while (*(string++)) rc++;
                      9:   else rc = -1;
                     10:   return rc;
                     11: }
                     12: 
                     13: int D_vsprintf(char *string, const char *format, int *argptr)
                     14: {
                     15:   int len, i, div, uselong;
                     16:   int fieldsize;
                     17:   unsigned long num;
                     18:   long snum;
                     19:   char padchar;
                     20:   char *str;
                     21:   char *origstring = string;
                     22: 
                     23:   while (*format)
                     24:   {
                     25:     if (*format != '%') *(string++) = *(format++);
                     26:     else
                     27:     {
                     28:       format++;
                     29: 
                     30:       /* set field pad character to 0 if necessary */
                     31:       if (*format == '0')
                     32:       {
                     33:         padchar = '0';
                     34:         format++;
                     35:       }
                     36:       else padchar = ' ';
                     37: 
                     38:       /* get the fieldwidth if any */
                     39:       fieldsize = 0;
                     40:       while (*format >= '0' && *format <= '9')
                     41:        fieldsize = fieldsize * 10 + *(format++) - '0';
                     42: 
                     43:       /* get rid of 'l' if present */
                     44:       if (*format == 'l')
                     45:       {
                     46:         uselong = 1;
                     47:         format++;
                     48:       } else uselong = 0;
                     49: 
                     50:       div = 10;
                     51:       if (*format == 'c')
                     52:       {
                     53:        *(string++) = *argptr++;
                     54:        format++;
                     55:       }
                     56:       else if (*format == 's')
                     57:       {
                     58:        str = (char *)*argptr++;
                     59:        len = mystrlen(str);
                     60:        while (fieldsize-- > len) *(string++) = padchar; /* do field pad */
                     61:        while (*str) *(string++) = *(str++); /* copy string */
                     62:        format++;
                     63:       }
                     64:       else
                     65:       {
                     66:         if (*format == 'o') /* octal */
                     67:         {
                     68:           div = 8;
                     69:           if (uselong)
                     70:            num = *argptr++;
                     71:          else 
                     72:            num = *argptr++;
                     73: /*       printf("o=0%o\n", num); */
                     74:         }
                     75:         else if (*format == 'x' || *format == 'X')  /* hex */
                     76:         {
                     77:           div = 16;
                     78:           if (uselong)
                     79:            num = *argptr++;
                     80:          else 
                     81:            num = *argptr++;
                     82: /*       printf("x=%x\n", num); */
                     83:        }
                     84:         else if (*format == 'i' || *format == 'd' || *format == 'u') /* decimal */
                     85:         {
                     86:           div = 10;
                     87:           if (uselong)
                     88:            snum = *argptr++;
                     89:          else
                     90:            snum = *argptr++;
                     91:          if (snum < 0 && *format != 'u') /* handle negative %i or %d */
                     92:          {
                     93:            *(string++) = '-';
                     94:            num = -snum;
                     95:            if (fieldsize) fieldsize--;
                     96:          } else num = snum;
                     97:        }
                     98:        else return -1; /* unrecognized format specifier */
                     99: 
                    100:        /* print any decimal or hex integer */
                    101:        len = 0;
                    102:        while (num || fieldsize || !len)
                    103:        {
                    104:          for (i=len ; i ; i--) string[i] = string[i-1]; /* shift right */
                    105:          if (len && fieldsize && !num) *string = padchar; /* pad out */
                    106:          else
                    107:          {
                    108:            /* put in a hex or decimal digit */
                    109:            *string = num % div;
                    110:            *string += *string > 9 ? 'A'-10 : '0';
                    111: /*         printf("d = %c\n", *string); */
                    112:            num /= div;
                    113:          }
                    114:          len++;
                    115:          if (fieldsize) fieldsize--;
                    116:        }
                    117:        string += len;
                    118:        format++;
                    119:       }
                    120:     }
                    121:   }
                    122:   *string = 0;
                    123: 
                    124:   return origstring - string;
                    125: }
                    126: 
                    127: 
                    128: /*
                    129: int mysprintf(char *string, char *format, ...)
                    130: {
                    131:   va_list argptr;
                    132:   va_start(argptr, format);
                    133:   return vsprintf(string, format, argptr);
                    134:   va_end(argptr);
                    135: }
                    136: 
                    137: main(int c, char **v)
                    138: {
                    139:   char buf[1024];
                    140:   mysprintf(buf, "%s %s %c 0x%x (%d) (0%o)!", "it", "works", '-', 0xdeadbeef,
                    141:     0xdeadbeef, 0xdeadbeef);
                    142: 
                    143:   puts(buf);
                    144: }
                    145: */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.