libc/stdio/doprintf.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2007  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   6  *
   7  *  This program is free software: you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation, either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21
  22 #include <_printf.h> /* fnptr_t */
  23 #include <string.h> /* strlen() */
  24 #include <stdarg.h> /* va_list, va_arg() */
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27
  28 int do_printf (const char *fmt, va_list args)
  29 {
  30         unsigned i = 0;
  31         unsigned count = 0;
  32         long num = 0;
  33         char str[16];
  34         unsigned char *buf = 0;
  35
  36         for (; *fmt; fmt ++) {
  37                 /* probably argument is here */
  38                 if (*fmt == '%') {
  39                         fmt ++;
  40
  41                         if (!*fmt)
  42                                 break;
  43
  44                         if (*fmt == 'd' || *fmt == 'i' || *fmt == 'u') {
  45                                 num = va_arg (args, int);
  46
  47                                 itoa (num, str, 10);
  48
  49                                 for (i = 0; str[i]; i ++)
  50                                         putch (str[i]);
  51
  52                                 count += i;
  53
  54                                 continue;
  55                         }
  56
  57                         if (*fmt == 'f') {
  58                                 num = va_arg (args, double);
  59
  60                                 int f;
  61
  62                                 if (num >= 1)
  63                                         f = (int) num;
  64                                 else {
  65                                         count += 2;
  66
  67                                         putch ('0');
  68                                         putch ('.');
  69
  70                                         f = (int) ((double) num * (double) 10000);
  71                                 }
  72
  73                                 itoa (f, str, 10);
  74
  75                                 for (i = 0; str[i]; i ++)
  76                                         putch (str[i]);
  77
  78                                 count += i;
  79
  80                                 continue;
  81                         }
  82
  83                         if (*fmt == 'x' || *fmt == 'X') {
  84                                 num = va_arg (args, int);
  85
  86                                 itoa (num, str, 16);
  87
  88                                 for (i = 0; str[i]; i ++)
  89                                         putch (str[i]);
  90
  91                                 count += i;
  92
  93                                 continue;
  94                         }
  95
  96                         if (*fmt == 'c') {
  97                                 num = va_arg (args, unsigned char);
  98
  99                                 putch ((unsigned char) num);
 100
 101                                 count ++;
 102
 103                                 continue;
 104                         }
 105
 106                         if (*fmt == 's') {
 107                                 buf = va_arg (args, unsigned char *);
 108
 109                                 for (i = 0; buf[i]; i ++)
 110                                         putch ((unsigned char) buf[i]);
 111
 112                                 count += i;
 113
 114                                 continue;
 115                         }
 116
 117                         continue;
 118                 }
 119
 120                 putch (*fmt);
 121                 count ++;
 122
 123         }
 124
 125         return count;
 126 }
 127
 128 int do_sprintf (const char *fmt, va_list args, char *ptr, int len)
 129 {
 130         unsigned i = 0;
 131         unsigned count = 0;
 132         long num = 0;
 133         char str[16];
 134         unsigned char *buf = 0;
 135
 136         for (; *fmt; fmt ++) {
 137                 /* probably argument is here */
 138                 if (*fmt == '%') {
 139                         fmt ++;
 140
 141                         if (!*fmt)
 142                                 break;
 143
 144                         if (*fmt == 'd' || *fmt == 'i' || *fmt == 'u') {
 145                                 num = va_arg (args, int);
 146
 147                                 itoa (num, str, 10);
 148
 149                                 for (i = 0; str[i]; i ++)
 150                                         ptr[i+count] = str[i];
 151
 152                                 count += i;
 153
 154                                 continue;
 155                         }
 156
 157                         if (*fmt == 'x' || *fmt == 'X') {
 158                                 num = va_arg (args, int);
 159
 160                                 itoa (num, str, 16);
 161
 162                                 for (i = 0; str[i]; i ++)
 163                                         ptr[i+count] = str[i];
 164
 165                                 count += i;
 166
 167                                 continue;
 168                         }
 169
 170                         if (*fmt == 'c') {
 171                                 num = va_arg (args, unsigned char);
 172
 173                                 ptr[count] = (unsigned char) num;
 174
 175                                 count ++;
 176
 177                                 continue;
 178                         }
 179
 180                         if (*fmt == 's') {
 181                                 buf = va_arg (args, unsigned char *);
 182
 183                                 for (i = 0; buf[i]; i ++)
 184                                         ptr[i+count] = buf[i];
 185
 186                                 count += i;
 187
 188                                 continue;
 189                         }
 190
 191                         continue;
 192                 }
 193
 194                 ptr[count] = *fmt;
 195                 count ++;
 196
 197                 if (len != -1)
 198                 if (count >= (unsigned) len)
 199                         break;
 200         }
 201
 202         return count;
 203 }
 204
 205 /*****************************************************************************
 206 VSPRINTF
 207 *****************************************************************************/
 208
 209 int vsprintf (char *buffer, const char *fmt, va_list args)
 210 {
 211         if (!fmt)
 212                 return 0;
 213
 214         int ret_val = do_sprintf (fmt, args, (char *) buffer, -1);
 215         buffer[ret_val] = '\0';
 216
 217         return ret_val;
 218 }
 219
 220 /*****************************************************************************
 221 VSNPRINTF
 222 *****************************************************************************/
 223
 224 int vsnprintf (char *buffer, size_t size, const char *fmt, va_list args)
 225 {
 226         if (!fmt)
 227                 return 0;
 228
 229         int ret_val = do_sprintf (fmt, args, (char *) buffer, size);
 230         buffer[ret_val] = '\0';
 231
 232         return ret_val;
 233 }
 234
 235 /*****************************************************************************
 236 VFPRINTF
 237 *****************************************************************************/
 238
 239 int vfprintf (FILE *stream, const char *fmt, va_list args)
 240 {
 241         if (!stream || !fmt)
 242                 return 0;
 243
 244         char *buffer = (char *) malloc (sizeof (char) * 256);
 245
 246         if (!buffer)
 247                 return 0;
 248
 249         int ret_val = do_sprintf (fmt, args, (char *) buffer, 255);
 250         buffer[ret_val] = '\0';
 251
 252         fwrite (buffer, ret_val, 1, stream);
 253
 254         free (buffer);
 255
 256         return ret_val;
 257 }
 258
 259
 260 #if 0 /* testing */
 261 /*****************************************************************************
 262 *****************************************************************************/
 263 int sprintf(char *buffer, const char *fmt, ...)
 264 {
 265         va_list args;
 266         int ret_val;
 267
 268         va_start(args, fmt);
 269         ret_val = vsprintf(buffer, fmt, args);
 270         va_end(args);
 271         return ret_val;
 272 }
 273 /*****************************************************************************
 274 PRINTF
 275 You must write your own putchar()
 276 *****************************************************************************/
 277 int vprintf_help(unsigned c, void **ptr)
 278 {
 279         putchar(c);
 280         return 0 ;
 281 }
 282 /*****************************************************************************
 283 *****************************************************************************/
 284 int vprintf(const char *fmt, va_list args)
 285 {
 286         return do_printf(fmt, args, vprintf_help, NULL);
 287 }
 288 /*****************************************************************************
 289 *****************************************************************************/
 290 int printf(const char *fmt, ...)
 291 {
 292         va_list args;
 293         int ret_val;
 294
 295         va_start(args, fmt);
 296         ret_val = vprintf(fmt, args);
 297         va_end(args);
 298         return ret_val;
 299 }
 300 /*****************************************************************************
 301 *****************************************************************************/
 302 int main(void)
 303 {
 304         char buf[64];
 305
 306         sprintf(buf, "%u score and %i years ago...\n", 4, -7);
 307         puts(buf);
 308
 309         sprintf(buf, "-1L == 0x%lX == octal %lo\n", -1L, -1L);
 310         puts(buf);
 311
 312         printf("<%-08s> and <%08s> justified strings\n", "left", "right");
 313         return 0;
 314 }
 315 #endif