freedt-va.patch

   1 diff -durN freedt-0.18.orig/iolib.c freedt-0.18/iolib.c
   2 --- freedt-0.18.orig/iolib.c    2003-05-27 20:06:16.000000000 +0200
   3 +++ freedt-0.18/iolib.c 2004-02-04 14:26:18.408747224 +0100
   4 @@ -212,50 +212,50 @@
   5  }
   6
   7  /* Format an argument into the buffer. */
   8 -static void format_arg(buffer *b, char t, va_list *va) {
   9 +static void format_arg(buffer *b, char t, va_list va) {
  10         switch (t) {
  11         case 'c': {
  12 -               char *s = va_arg(*va, char *);
  13 +               char *s = va_arg(va, char *);
  14                 bappends(b, s);
  15                 break;
  16         }
  17         case 'b': {
  18 -               buffer *src = va_arg(*va, buffer *);
  19 +               buffer *src = va_arg(va, buffer *);
  20                 bappend(b, src);
  21                 break;
  22         }
  23         case 'i': {
  24 -               int i = va_arg(*va, int);
  25 +               int i = va_arg(va, int);
  26                 format_long(b, i, 10);
  27                 break;
  28         }
  29         case 'I': {
  30 -               unsigned int i = va_arg(*va, unsigned int);
  31 +               unsigned int i = va_arg(va, unsigned int);
  32                 format_ulong(b, i, 10);
  33                 break;
  34         }
  35         case 'x': {
  36 -               int i = va_arg(*va, int);
  37 +               int i = va_arg(va, int);
  38                 format_long(b, i, 16);
  39                 break;
  40         }
  41         case 'X': {
  42 -               unsigned int i = va_arg(*va, unsigned int);
  43 +               unsigned int i = va_arg(va, unsigned int);
  44                 format_ulong(b, i, 16);
  45                 break;
  46         }
  47         case 'l': {
  48 -               long i = va_arg(*va, long);
  49 +               long i = va_arg(va, long);
  50                 format_long(b, i, 10);
  51                 break;
  52         }
  53         case 'L': {
  54 -               unsigned long i = va_arg(*va, unsigned long);
  55 +               unsigned long i = va_arg(va, unsigned long);
  56                 format_ulong(b, i, 10);
  57                 break;
  58         }
  59         case 'a': {
  60 -               unsigned long i = va_arg(*va, unsigned long);
  61 +               unsigned long i = va_arg(va, unsigned long);
  62                 format_long(b, i & 0xff, 10);
  63                 bappendc(b, '.');
  64                 format_long(b, (i >> 8) & 0xff, 10);
  65 @@ -285,7 +285,7 @@
  66                 ++p;
  67                 if (*p == '\0')
  68                         die("unexpected end of format");
  69 -               format_arg(b, *p, &va);
  70 +               format_arg(b, *p, va);
  71
  72                 fmt = p + 1;
  73         }
  74 diff -durN freedt-0.18.orig/iolib.c~ freedt-0.18/iolib.c~
  75 --- freedt-0.18.orig/iolib.c~   1970-01-01 01:00:00.000000000 +0100
  76 +++ freedt-0.18/iolib.c~        2003-05-27 20:06:16.000000000 +0200
  77 @@ -0,0 +1,316 @@
  78 +#include <stdlib.h>
  79 +#include <unistd.h>
  80 +#include <string.h>
  81 +#include <sys/types.h>
  82 +#include <sys/stat.h>
  83 +#include <fcntl.h>
  84 +#include <errno.h>
  85 +#include <stdarg.h>
  86 +#include "iolib.h"
  87 +#include "config.h"
  88 +
  89 +/* Default file descriptors. */
  90 +int fd_in = 0;
  91 +int fd_out = 1;
  92 +int fd_err = 2;
  93 +
  94 +/* The granularity with which to allocate buffer sizes;
  95 +   the allocated size of a buffer will always be a multiple of this. */
  96 +#define BUFFERUNIT 256
  97 +
  98 +/* Die with a constant error message. */
  99 +#define die(s) do { write(2, s, sizeof(s) - 1); exit(20); } while (0)
 100 +
 101 +/* Adjust the size of a buffer without destroying its contents. */
 102 +static void bsetsize(buffer *b, int len) {
 103 +       if (len == 0) {
 104 +               if (b->s != NULL)
 105 +                       free(b->s);
 106 +               b->s = NULL;
 107 +               b->size = 0;
 108 +       } else {
 109 +               /* This always rounds up the allocated size so that
 110 +                  adding characters to a buf one at a time doesn't
 111 +                  cause a realloc for each character. */
 112 +               int size = BUFFERUNIT * ((len / BUFFERUNIT) + 1);
 113 +               if (size != b->size) {
 114 +                       b->s = realloc(b->s, size + 1);
 115 +                       if (b->s == NULL)
 116 +                               die("out of memory");
 117 +                       b->size = size;
 118 +               }
 119 +       }
 120 +}
 121 +
 122 +void bsetlength(buffer *b, int len) {
 123 +       bsetsize(b, len);
 124 +       b->len = len;
 125 +}
 126 +
 127 +void bfree(buffer *b) {
 128 +       bsetlength(b, 0);
 129 +}
 130 +
 131 +void bmake(buffer *b, const char *s) {
 132 +       bsetlength(b, 0);
 133 +       bappendm(b, s, strlen(s));
 134 +}
 135 +
 136 +void bappendm(buffer *dest, const char *src, int len) {
 137 +       int l = dest->len;
 138 +       bsetlength(dest, l + len);
 139 +       memcpy(dest->s + l, src, len);
 140 +}
 141 +
 142 +void bappends(buffer *dest, const char *s) {
 143 +       bappendm(dest, s, strlen(s));
 144 +}
 145 +
 146 +void bappendc(buffer *dest, char c) {
 147 +       bappendm(dest, &c, 1);
 148 +}
 149 +
 150 +void bappend(buffer *dest, const buffer *src) {
 151 +       bappendm(dest, src->s, src->len);
 152 +}
 153 +
 154 +int blength(const buffer *b) {
 155 +       return b->len;
 156 +}
 157 +
 158 +const char *bstr(const buffer *b) {
 159 +       if (b->len == 0) return "";
 160 +       b->s[b->len] = '\0';
 161 +       return b->s;
 162 +}
 163 +
 164 +int bindex(const buffer *b, char c) {
 165 +       char *pos;
 166 +
 167 +       if (b->len == 0)
 168 +               return -1;
 169 +
 170 +       pos = (char *) memchr(b->s, c, b->len);
 171 +       if (pos == NULL)
 172 +               return -1;
 173 +       else
 174 +               return pos - b->s;
 175 +}
 176 +
 177 +void breplacec(buffer *b, char from, char to) {
 178 +       char *p = b->s, *end = p + b->len;
 179 +       for (; p < end; p++) {
 180 +               if (*p == from) *p = to;
 181 +       }
 182 +}
 183 +
 184 +void bpopl(buffer *b, int n, buffer *saveto) {
 185 +       if (saveto != NULL)
 186 +               bappendm(saveto, b->s, n);
 187 +       /* FIXME: It would be more efficient to maintain a "start" pointer
 188 +          and only memmove once we have more than a certain amount of space
 189 +          wasted. */
 190 +       b->len -= n;
 191 +       memmove(b->s, b->s + n, b->len);
 192 +}
 193 +
 194 +int writea(int fd, const char *s, int n) {
 195 +       while (n > 0) {
 196 +               int c;
 197 +
 198 +               do {
 199 +                       c = write(fd, s, n);
 200 +               } while (c < 0 && errno == EINTR);
 201 +               if (c < 0)
 202 +                       return -1;
 203 +
 204 +               s += c;
 205 +               n -= c;
 206 +       }
 207 +       return 0;
 208 +}
 209 +
 210 +int writeb(int fd, const buffer *b) {
 211 +       return write(fd, b->s, b->len);
 212 +}
 213 +
 214 +int writeba(int fd, const buffer *b) {
 215 +       return writea(fd, b->s, b->len);
 216 +}
 217 +
 218 +int readb(int fd, buffer *b, int n) {
 219 +       int c;
 220 +
 221 +       if (n == 0)
 222 +               return 0;
 223 +
 224 +       if (b->size < (b->len + n))
 225 +               bsetsize(b, b->len + n);
 226 +
 227 +       c = read(fd, b->s + b->len, n);
 228 +       if (c > 0)
 229 +               b->len += c;
 230 +
 231 +       return c;
 232 +}
 233 +
 234 +int readba(int fd, buffer *b) {
 235 +       int c;
 236 +       do {
 237 +               c = readb(fd, b, 4096);
 238 +       } while (c > 0);
 239 +       return c;
 240 +}
 241 +
 242 +int readuntilb(int fd, buffer *b, int max, char term, buffer *overflow) {
 243 +       while (1) {
 244 +               int c;
 245 +               char *pos;
 246 +
 247 +               pos = (char *) memchr(overflow->s, term, overflow->len);
 248 +               if (pos != NULL) {
 249 +                       /* Remove the \n from overflow, but also trim it
 250 +                          from the string read. */
 251 +                       bpopl(overflow, 1 + pos - overflow->s, b);
 252 +                       bsetlength(b, b->len - 1);
 253 +                       return 1;
 254 +               }
 255 +
 256 +               /* If no maximum size is specified, then read as much as
 257 +                  possible. */
 258 +               c = readb(fd, overflow, (max) ? (max - overflow->len) : 4096);
 259 +               if (c <= 0)
 260 +                       return c;
 261 +       }
 262 +}
 263 +
 264 +int readlineb(int fd, buffer *b, int max, buffer *overflow) {
 265 +       return readuntilb(fd, b, max, '\n', overflow);
 266 +}
 267 +
 268 +/* Return the representation of a digit. */
 269 +static char format_digit(int n) {
 270 +       if (n < 10) return '0' + n;
 271 +       if (n < 36) return 'A' + (n - 10);
 272 +       return '!';
 273 +}
 274 +
 275 +/* Format an unsigned long into the buffer. */
 276 +static void format_ulong(buffer *b, unsigned long n, int base) {
 277 +       if (n >= base) format_ulong(b, n / base, base);
 278 +       bappendc(b, format_digit(n % base));
 279 +}
 280 +
 281 +/* Format a signed long into the buffer. */
 282 +static void format_long(buffer *b, long n, int base) {
 283 +       if (n < 0) {
 284 +               bappendc(b, '-');
 285 +               format_ulong(b, -n, base);
 286 +       } else {
 287 +               format_ulong(b, n, base);
 288 +       }
 289 +}
 290 +
 291 +/* Format an argument into the buffer. */
 292 +static void format_arg(buffer *b, char t, va_list *va) {
 293 +       switch (t) {
 294 +       case 'c': {
 295 +               char *s = va_arg(*va, char *);
 296 +               bappends(b, s);
 297 +               break;
 298 +       }
 299 +       case 'b': {
 300 +               buffer *src = va_arg(*va, buffer *);
 301 +               bappend(b, src);
 302 +               break;
 303 +       }
 304 +       case 'i': {
 305 +               int i = va_arg(*va, int);
 306 +               format_long(b, i, 10);
 307 +               break;
 308 +       }
 309 +       case 'I': {
 310 +               unsigned int i = va_arg(*va, unsigned int);
 311 +               format_ulong(b, i, 10);
 312 +               break;
 313 +       }
 314 +       case 'x': {
 315 +               int i = va_arg(*va, int);
 316 +               format_long(b, i, 16);
 317 +               break;
 318 +       }
 319 +       case 'X': {
 320 +               unsigned int i = va_arg(*va, unsigned int);
 321 +               format_ulong(b, i, 16);
 322 +               break;
 323 +       }
 324 +       case 'l': {
 325 +               long i = va_arg(*va, long);
 326 +               format_long(b, i, 10);
 327 +               break;
 328 +       }
 329 +       case 'L': {
 330 +               unsigned long i = va_arg(*va, unsigned long);
 331 +               format_ulong(b, i, 10);
 332 +               break;
 333 +       }
 334 +       case 'a': {
 335 +               unsigned long i = va_arg(*va, unsigned long);
 336 +               format_long(b, i & 0xff, 10);
 337 +               bappendc(b, '.');
 338 +               format_long(b, (i >> 8) & 0xff, 10);
 339 +               bappendc(b, '.');
 340 +               format_long(b, (i >> 16) & 0xff, 10);
 341 +               bappendc(b, '.');
 342 +               format_long(b, (i >> 24) & 0xff, 10);
 343 +               break;
 344 +       }
 345 +       case '@': {
 346 +               bappendc(b, '@');
 347 +               break;
 348 +       }
 349 +       default:
 350 +               die("unknown format character");
 351 +       }
 352 +}
 353 +
 354 +/* Format a list of arguments into the buffer. */
 355 +static void vaformat(buffer *b, const char *fmt, va_list va) {
 356 +       while (1) {
 357 +               const char *p = strchr(fmt, '@');
 358 +               if (p == NULL)
 359 +                       break;
 360 +
 361 +               bappendm(b, fmt, p - fmt);
 362 +               ++p;
 363 +               if (*p == '\0')
 364 +                       die("unexpected end of format");
 365 +               format_arg(b, *p, &va);
 366 +
 367 +               fmt = p + 1;
 368 +       }
 369 +       bappends(b, fmt);
 370 +}
 371 +
 372 +int format(int fd, const char *fmt, ...) {
 373 +       int r;
 374 +       va_list va;
 375 +       buffer b = BUFFER;
 376 +
 377 +       va_start(va, fmt);
 378 +       vaformat(&b, fmt, va);
 379 +       r = writeba(fd, &b);
 380 +       bfree(&b);
 381 +       va_end(va);
 382 +
 383 +       return r;
 384 +}
 385 +
 386 +void bformat(buffer *b, const char *fmt, ...) {
 387 +       va_list va;
 388 +
 389 +       va_start(va, fmt);
 390 +       vaformat(b, fmt, va);
 391 +       va_end(va);
 392 +}
 393 +