scanf.c

   1 #include <stdarg.h>
   2 #include <stdio.h>
   3 #include <unistd.h>
   4 #include <string.h>
   5
   6 static int ic(FILE *fp)
   7 {
   8         int nr;
   9         if (fp->back != EOF) {
  10                 int i = fp->back;
  11                 fp->back = EOF;
  12                 return i;
  13         }
  14         while (fp->fd >= 0 && fp->icur == fp->ilen) {
  15                 int nr = read(fp->fd, fp->ibuf, fp->isize);
  16                 if (nr <= 0)
  17                         break;
  18                 fp->ilen = nr;
  19                 fp->icur = 0;
  20         }
  21         return fp->icur < fp->ilen ? (unsigned char) fp->ibuf[fp->icur++] : EOF;
  22 }
  23
  24 void setbuf(FILE *fp, char *buf)
  25 {
  26 }
  27
  28 int fgetc(FILE *fp)
  29 {
  30         return ic(fp);
  31 }
  32
  33 int getchar(void)
  34 {
  35         return ic(stdin);
  36 }
  37
  38 int ungetc(int c, FILE *fp)
  39 {
  40         if (fp->back == EOF)
  41                 fp->back = c;
  42         return fp->back;
  43 }
  44
  45 /* t is 1 for char, 2 for short, 4 for int, and 8 for long */
  46 static int iint(FILE *fp, void *dst, int t)
  47 {
  48         long n = 0;
  49         int c;
  50         int neg = 0;
  51         c = ic(fp);
  52         if (c == '-')
  53                 neg = 1;
  54         if (c == '-' || c == '+')
  55                 c = ic(fp);
  56         if (!isdigit(c)) {
  57                 ungetc(c, fp);
  58                 return 1;
  59         }
  60         do {
  61                 n = n * 10 + c - '0';
  62         } while (isdigit(c = ic(fp)));
  63         ungetc(c, fp);
  64         if (t == 8)
  65                 *(long *) dst = neg ? -n : n;
  66         else if (t == 4)
  67                 *(int *) dst = neg ? -n : n;
  68         else if (t == 2)
  69                 *(short *) dst = neg ? -n : n;
  70         else
  71                 *(char *) dst = neg ? -n : n;
  72         return 0;
  73 }
  74
  75 static int istr(FILE *fp, char *dst)
  76 {
  77         char *d = dst;
  78         int c;
  79         while ((c = ic(fp)) != EOF && !isspace(c))
  80                 *d++ = c;
  81         *d = '\0';
  82         ungetc(c, fp);
  83         return d == dst;
  84 }
  85
  86 int vfscanf(FILE *fp, char *fmt, va_list ap)
  87 {
  88         int ret = 0;
  89         int t, c;
  90         while (*fmt) {
  91                 while (isspace(*fmt))
  92                         fmt++;
  93                 while (isspace(c = ic(fp)))
  94                         ;
  95                 ungetc(c, fp);
  96                 while (*fmt && *fmt != '%' && !isspace(*fmt))
  97                         if (*fmt++ != ic(fp))
  98                                 return ret;
  99                 if (*fmt != '%')
 100                         continue;
 101                 fmt++;
 102                 t = sizeof(int);
 103                 while (*fmt == 'l') {
 104                         t = sizeof(long);
 105                         fmt++;
 106                 }
 107                 while (*fmt == 'h') {
 108                         t = t < sizeof(int) ? sizeof(char) : sizeof(short);
 109                         fmt++;
 110                 }
 111                 switch (*fmt++) {
 112                 case 'u':
 113                 case 'd':
 114                         if (iint(fp, va_arg(ap, long *), t))
 115                                 return ret;
 116                         ret++;
 117                         break;
 118                 case 's':
 119                         if (istr(fp, va_arg(ap, char *)))
 120                                 return ret;
 121                         ret++;
 122                         break;
 123                 }
 124         }
 125         return ret;
 126 }
 127
 128 int fscanf(FILE *fp, char *fmt, ...)
 129 {
 130         va_list ap;
 131         int ret;
 132         va_start(ap, fmt);
 133         ret = vfscanf(fp, fmt, ap);
 134         va_end(ap);
 135         return ret;
 136 }
 137
 138 int scanf(char *fmt, ...)
 139 {
 140         va_list ap;
 141         int ret;
 142         va_start(ap, fmt);
 143         ret = vfscanf(stdin, fmt, ap);
 144         va_end(ap);
 145         return ret;
 146 }
 147
 148 int vsscanf(char *s, char *fmt, va_list ap)
 149 {
 150         FILE f = {-1, EOF};
 151         f.ibuf = s;
 152         f.ilen = strlen(s);
 153         return vfscanf(&f, fmt, ap);
 154 }
 155
 156 int sscanf(char *s, char *fmt, ...)
 157 {
 158         va_list ap;
 159         int ret;
 160         va_start(ap, fmt);
 161         ret = vsscanf(s, fmt, ap);
 162         va_end(ap);
 163         return ret;
 164 }
 165
 166 char *fgets(char *s, int sz, FILE *fp)
 167 {
 168         int i = 0;
 169         int c;
 170         while (i + 1 < sz && (c = ic(fp)) != EOF) {
 171                 s[i++] = c;
 172                 if (c == '\n')
 173                         break;
 174         }
 175         s[i] = '\0';
 176         return i ? s : NULL;
 177 }