]> git.saurik.com Git - apple/libc.git/blob - stdio/FreeBSD/vfwprintf.c.patch
projects / apple / libc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Libc-320.tar.gz
[apple/libc.git] / stdio / FreeBSD / vfwprintf.c.patch
1 --- vfwprintf.c.orig Thu Jul 24 12:42:14 2003
2 +++ vfwprintf.c Sun Aug 24 16:22:23 2003
3 @@ -70,9 +70,20 @@
4 #include "local.h"
5 #include "fvwrite.h"
6
7 +#ifdef ALTIVEC
8 +#include <machine/cpu_capabilities.h>
9 +
10 +#define VECTORTYPE vector unsigned char
11 +#endif /* ALTIVEC */
12 +
13 /* Define FLOATING_POINT to get floating point. */
14 #define FLOATING_POINT
15
16 +/* if no floating point, turn off HEXFLOAT as well */
17 +#if defined(HEXFLOAT) && !defined(FLOATING_POINT)
18 +#undef HEXFLOAT
19 +#endif /* defined(HEXFLOAT) && !defined(FLOATING_POINT) */
20 +
21 union arg {
22 int intarg;
23 u_int uintarg;
24 @@ -92,7 +103,7 @@
25 long *plongarg;
26 long long *plonglongarg;
27 ptrdiff_t *pptrdiffarg;
28 - size_t *psizearg;
29 + ssize_t *psizearg;
30 intmax_t *pintmaxarg;
31 #ifdef FLOATING_POINT
32 double doublearg;
33 @@ -100,6 +111,16 @@
34 #endif
35 wint_t wintarg;
36 wchar_t *pwchararg;
37 +#ifdef ALTIVEC
38 + VECTORTYPE vectorarg;
39 + unsigned char vuchararg[16];
40 + signed char vchararg[16];
41 + unsigned short vushortarg[8];
42 + signed short vshortarg[8];
43 + unsigned int vuintarg[4];
44 + signed int vintarg[4];
45 + float vfloatarg[4];
46 +#endif /* ALTIVEC */
47 };
48
49 /*
50 @@ -110,7 +131,11 @@
51 T_LONG, T_U_LONG, TP_LONG, T_LLONG, T_U_LLONG, TP_LLONG,
52 T_PTRDIFFT, TP_PTRDIFFT, T_SIZET, TP_SIZET,
53 T_INTMAXT, T_UINTMAXT, TP_INTMAXT, TP_VOID, TP_CHAR, TP_SCHAR,
54 +#ifdef ALTIVEC
55 + T_DOUBLE, T_LONG_DOUBLE, T_WINT, TP_WCHAR, T_VECTOR
56 +#else /* ! ALTIVEC */
57 T_DOUBLE, T_LONG_DOUBLE, T_WINT, TP_WCHAR
58 +#endif /* ALTIVEC */
59 };
60
61 static int __sbprintf(FILE *, const wchar_t *, va_list);
62 @@ -122,6 +147,37 @@
63 static void __find_arguments(const wchar_t *, va_list, union arg **);
64 static void __grow_type_table(int, enum typeid **, int *);
65
66 + /*
67 + * Get the argument indexed by nextarg. If the argument table is
68 + * built, use it to get the argument. If its not, get the next
69 + * argument (and arguments must be gotten sequentially).
70 + */
71 +#define GETARG(type) \
72 + ((argtable != NULL) ? *((type*)(&argtable[nextarg++])) : \
73 + (nextarg++, va_arg(ap, type)))
74 +
75 +#ifdef ALTIVEC
76 +#define hasAltivec (_cpu_capabilities & kHasAltivec)
77 +/*-----------------------------------------------------------------------
78 + * getvec() must be a real subroutine. If it is a #define, then __vfprintf()
79 + * would have its calling sequence changed by Altivec so that a non-Altivec
80 + * processor would crash on illegal instruction. By isolating the calling
81 + * sequence in getvec(), __vprintf() is callable by a non-Altivec processor.
82 + *-----------------------------------------------------------------------*/
83 +static va_list
84 +getvec(union arg *dst, const union arg *argtable, int nextarg, va_list ap)
85 +{
86 + dst->vectorarg = GETARG(VECTORTYPE);
87 + return ap;
88 +}
89 +
90 +#define SETVEC(dst) \
91 +{ \
92 + ap = getvec(&dst, argtable, nextarg, ap); \
93 + nextarg++; \
94 +}
95 +#endif /* ALTIVEC */
96 +
97 /*
98 * Helper function for `fprintf to unbuffered unix file': creates a
99 * temporary buffer. We only work on write-only files; this avoids
100 @@ -418,6 +474,15 @@
101
102 #endif /* FLOATING_POINT */
103
104 +#ifdef HEXFLOAT
105 +extern int __hdtoa(double d, const char *xdigs, int prec, char *cp,
106 + int *expt, int *signflag, char **dtoaend);
107 +#if !__TYPE_LONGDOUBLE_IS_DOUBLE
108 +extern int __hldtoa(long double d, const char *xdigs, int prec, char *cp,
109 + int *expt, int *signflag, char **dtoaend);
110 +#endif /* !__TYPE_LONGDOUBLE_IS_DOUBLE */
111 +#endif /* HEXFLOAT */
112 +
113 /*
114 * The size of the buffer we use as scratch space for integer
115 * conversions, among other things. Technically, we would need the
116 @@ -446,6 +511,9 @@
117 #define PTRDIFFT 0x800 /* ptrdiff_t */
118 #define INTMAXT 0x1000 /* intmax_t */
119 #define CHARINT 0x2000 /* print char using int format */
120 +#ifdef ALTIVEC
121 +#define VECTOR 0x4000 /* Altivec vector */
122 +#endif /* ALTIVEC */
123
124 /*
125 * Non-MT-safe version
126 @@ -496,6 +564,11 @@
127 int nseps; /* number of group separators with ' */
128 int nrepeats; /* number of repeats of the last group */
129 #endif
130 +#ifdef ALTIVEC
131 + union arg vval; /* Vector argument. */
132 + wchar_t *pct; /* Pointer to '%' at beginning of specifier. */
133 + wchar_t vsep; /* Vector separator character. */
134 +#endif
135 u_long ulval; /* integer arguments %[diouxX] */
136 uintmax_t ujval; /* %j, %ll, %q, %t, %z integers */
137 int base; /* base for [diouxX] conversion */
138 @@ -525,6 +598,15 @@
139
140 static const wchar_t xdigs_lower[16] = L"0123456789abcdef";
141 static const wchar_t xdigs_upper[16] = L"0123456789ABCDEF";
142 +#ifdef HEXFLOAT
143 +#define HEXFLOATDELTA 32
144 +#define HEXFLOATSTART 32
145 + static char *hexfloat = NULL;
146 + static int hexfloatlen = 0;
147 + const char *xdigs0; /* digits for [aA] conversion */
148 + static const char xdigs_lower0[16] = "0123456789abcdef";
149 + static const char xdigs_upper0[16] = "0123456789ABCDEF";
150 +#endif /* HEXFLOAT */
151
152 /*
153 * BEWARE, these `goto error' on error, PRINT uses `n2' and
154 @@ -553,15 +635,6 @@
155 } while(0)
156
157 /*
158 - * Get the argument indexed by nextarg. If the argument table is
159 - * built, use it to get the argument. If its not, get the next
160 - * argument (and arguments must be gotten sequentially).
161 - */
162 -#define GETARG(type) \
163 - ((argtable != NULL) ? *((type*)(&argtable[nextarg++])) : \
164 - (nextarg++, va_arg(ap, type)))
165 -
166 - /*
167 * To extend shorts properly, we need both signed and unsigned
168 * argument extraction methods.
169 */
170 @@ -612,7 +685,6 @@
171 val = GETARG (int); \
172 }
173
174 -
175 thousands_sep = '\0';
176 grouping = NULL;
177 #ifdef FLOATING_POINT
178 @@ -650,6 +722,9 @@
179 }
180 if (ch == '\0')
181 goto done;
182 +#ifdef ALTIVEC
183 + pct = fmt;
184 +#endif /* ALTIVEC */
185 fmt++; /* skip over '%' */
186
187 flags = 0;
188 @@ -658,6 +733,9 @@
189 prec = -1;
190 sign = '\0';
191 ox[1] = '\0';
192 +#ifdef ALTIVEC
193 + vsep = 'X'; /* Illegal value, changed to defaults later. */
194 +#endif /* ALTIVEC */
195
196 rflag: ch = *fmt++;
197 reswitch: switch (ch) {
198 @@ -673,6 +751,11 @@
199 case '#':
200 flags |= ALT;
201 goto rflag;
202 +#ifdef ALTIVEC
203 + case ',': case ';': case ':': case '_':
204 + vsep = ch;
205 + goto rflag;
206 +#endif /* ALTIVEC */
207 case '*':
208 /*-
209 * ``A negative field width argument is taken as a
210 @@ -770,8 +853,18 @@
211 case 'c':
212 if (flags & LONGINT)
213 *(cp = buf) = (wchar_t)GETARG(wint_t);
214 +#ifdef ALTIVEC
215 + else {
216 + if (flags & VECTOR) {
217 + SETVEC(vval);
218 + break;
219 + }
220 + *(cp = buf) = (wchar_t)btowc(GETARG(int));
221 + }
222 +#else /* ALTIVEC */
223 else
224 *(cp = buf) = (wchar_t)btowc(GETARG(int));
225 +#endif /* ALTIVEC */
226 size = 1;
227 sign = '\0';
228 break;
229 @@ -780,6 +873,12 @@
230 /*FALLTHROUGH*/
231 case 'd':
232 case 'i':
233 +#ifdef ALTIVEC
234 + if (flags & VECTOR) {
235 + SETVEC(vval);
236 + break;
237 + } else
238 +#endif /* ALTIVEC */
239 if (flags & INTMAX_SIZE) {
240 ujval = SJARG();
241 if ((intmax_t)ujval < 0) {
242 @@ -799,38 +898,74 @@
243 #ifdef HEXFLOAT
244 case 'a':
245 case 'A':
246 +#ifdef ALTIVEC
247 + if (flags & VECTOR) {
248 + flags |= FPT;
249 + SETVEC(vval);
250 + break;
251 + }
252 +#endif /* ALTIVEC */
253 if (ch == 'a') {
254 ox[1] = 'x';
255 - xdigs = xdigs_lower;
256 + xdigs0 = xdigs_lower0;
257 expchar = 'p';
258 } else {
259 ox[1] = 'X';
260 - xdigs = xdigs_upper;
261 + xdigs0 = xdigs_upper0;
262 expchar = 'P';
263 }
264 - /*
265 - * XXX We don't actually have a conversion
266 - * XXX routine for this yet.
267 - */
268 + if (!hexfloat) {
269 + hexfloat = malloc(hexfloatlen = HEXFLOATSTART);
270 + if (!hexfloat)
271 + goto error;
272 + }
273 + /* one extra for integer part and another for null */
274 + if (prec > hexfloatlen - 2) {
275 + int hlen = prec + HEXFLOATDELTA;
276 + char *hf = realloc(hexfloat, hlen);
277 + if (hf == NULL)
278 + goto error;
279 + hexfloat = hf;
280 + hexfloatlen = hlen;
281 + }
282 if (flags & LONGDBL) {
283 - fparg.ldbl = (double)GETARG(long double);
284 - dtoaresult =
285 - __hldtoa(fparg.ldbl, xdigs, prec,
286 - &expt, &signflag, &dtoaend);
287 +#if __TYPE_LONGDOUBLE_IS_DOUBLE
288 + fparg.dbl = (double)GETARG(long double);
289 + prec = __hdtoa(fparg.dbl, xdigs0, prec,
290 + hexfloat, &expt, &signflag, &dtoaend);
291 +#else /* ! __TYPE_LONGDOUBLE_IS_DOUBLE */
292 + fparg.ldbl = GETARG(long double);
293 + prec = __hldtoa(fparg.ldbl, xdigs0, prec,
294 + hexfloat, &expt, &signflag, &dtoaend);
295 +#endif /* __TYPE_LONGDOUBLE_IS_DOUBLE */
296 } else {
297 fparg.dbl = GETARG(double);
298 - dtoaresult =
299 - __hdtoa(fparg.dbl, xdigs, prec,
300 - &expt, &signflag, &dtoaend);
301 + prec = __hdtoa(fparg.dbl, xdigs0, prec,
302 + hexfloat, &expt, &signflag, &dtoaend);
303 + }
304 + prec++;
305 + if (expt == INT_MAX) {
306 + ox[1] = 0;
307 + hexfloat[1] = 0;
308 + } else {
309 + expt++;
310 + *dtoaend = 0;
311 + ndig = dtoaend - hexfloat;
312 }
313 if (convbuf != NULL)
314 free(convbuf);
315 - cp = convbuf = __mbsconv(dtoaresult, -1);
316 - freedtoa(dtoaresult);
317 - goto fp_begin;
318 + cp = convbuf = __mbsconv(hexfloat, -1);
319 + goto hex_begin;
320 #endif
321 case 'e':
322 case 'E':
323 +#ifdef ALTIVEC
324 + if (flags & VECTOR) {
325 + flags |= FPT;
326 + SETVEC(vval);
327 + break;
328 + }
329 +#endif /* ALTIVEC */
330 expchar = ch;
331 if (prec < 0) /* account for digit before decpt */
332 prec = DEFPREC + 1;
333 @@ -839,10 +974,24 @@
334 goto fp_begin;
335 case 'f':
336 case 'F':
337 +#ifdef ALTIVEC
338 + if (flags & VECTOR) {
339 + flags |= FPT;
340 + SETVEC(vval);
341 + break;
342 + }
343 +#endif /* ALTIVEC */
344 expchar = '\0';
345 goto fp_begin;
346 case 'g':
347 case 'G':
348 +#ifdef ALTIVEC
349 + if (flags & VECTOR) {
350 + flags |= FPT;
351 + SETVEC(vval);
352 + break;
353 + }
354 +#endif /* ALTIVEC */
355 expchar = ch - ('g' - 'e');
356 if (prec == 0)
357 prec = 1;
358 @@ -851,6 +1000,17 @@
359 prec = DEFPREC;
360 if (convbuf != NULL)
361 free(convbuf);
362 +#if __TYPE_LONGDOUBLE_IS_DOUBLE
363 + if (flags & LONGDBL)
364 + fparg.ldbl = GETARG(long double);
365 + else
366 + fparg.dbl = GETARG(double);
367 + dtoaresult =
368 + dtoa(fparg.dbl, expchar ? 2 : 3, prec,
369 + &expt, &signflag, &dtoaend);
370 + if (expt == 9999)
371 + expt = INT_MAX;
372 +#else /* ! __TYPE_LONGDOUBLE_IS_DOUBLE */
373 if (flags & LONGDBL) {
374 fparg.ldbl = GETARG(long double);
375 dtoaresult =
376 @@ -864,9 +1024,13 @@
377 if (expt == 9999)
378 expt = INT_MAX;
379 }
380 +#endif /* __TYPE_LONGDOUBLE_IS_DOUBLE */
381 ndig = dtoaend - dtoaresult;
382 cp = convbuf = __mbsconv(dtoaresult, -1);
383 freedtoa(dtoaresult);
384 +#ifdef HEXFLOAT
385 +hex_begin:
386 +#endif /* HEXFLOAT */
387 if (signflag)
388 sign = '-';
389 if (expt == INT_MAX) { /* inf or nan */
390 @@ -959,6 +1123,12 @@
391 flags |= LONGINT;
392 /*FALLTHROUGH*/
393 case 'o':
394 +#ifdef ALTIVEC
395 + if (flags & VECTOR) {
396 + SETVEC(vval);
397 + break;
398 + } else
399 +#endif /* ALTIVEC */
400 if (flags & INTMAX_SIZE)
401 ujval = UJARG();
402 else
403 @@ -973,6 +1143,12 @@
404 * defined manner.''
405 * -- ANSI X3J11
406 */
407 +#ifdef ALTIVEC
408 + if (flags & VECTOR) {
409 + SETVEC(vval);
410 + break;
411 + }
412 +#endif /* ALTIVEC */
413 ujval = (uintmax_t)(uintptr_t)GETARG(void *);
414 base = 16;
415 xdigs = xdigs_lower;
416 @@ -1025,6 +1201,12 @@
417 flags |= LONGINT;
418 /*FALLTHROUGH*/
419 case 'u':
420 +#ifdef ALTIVEC
421 + if (flags & VECTOR) {
422 + SETVEC(vval);
423 + break;
424 + } else
425 +#endif /* ALTIVEC */
426 if (flags & INTMAX_SIZE)
427 ujval = UJARG();
428 else
429 @@ -1037,6 +1219,12 @@
430 case 'x':
431 xdigs = xdigs_lower;
432 hex:
433 +#ifdef ALTIVEC
434 + if (flags & VECTOR) {
435 + SETVEC(vval);
436 + break;
437 + } else
438 +#endif /* ALTIVEC */
439 if (flags & INTMAX_SIZE)
440 ujval = UJARG();
441 else
442 @@ -1081,6 +1269,14 @@
443 if (size > BUF) /* should never happen */
444 abort();
445 break;
446 +#ifdef ALTIVEC
447 + case 'v':
448 + if (hasAltivec) {
449 + flags |= VECTOR;
450 + goto rflag;
451 + }
452 + /* drop through */
453 +#endif /* ALTIVEC */
454 default: /* "%?" prints ?, unless ? is NUL */
455 if (ch == '\0')
456 goto done;
457 @@ -1092,6 +1288,185 @@
458 break;
459 }
460
461 +#ifdef ALTIVEC
462 + if (flags & VECTOR) {
463 + /*
464 + * Do the minimum amount of work necessary to construct
465 + * a format specifier that can be used to recursively
466 + * call vfprintf() for each element in the vector.
467 + */
468 + int i, j; /* Counter. */
469 + int vcnt; /* Number of elements in vector. */
470 + char *vfmt; /* Pointer to format specifier. */
471 + char vfmt_buf[32]; /* Static buffer for format spec. */
472 + int vwidth = 0; /* Width specified via '*'. */
473 + int vprec = 0; /* Precision specified via '*'. */
474 + union { /* Element. */
475 + int i;
476 + float f;
477 + } velm;
478 + char *vstr; /* Used for asprintf(). */
479 + int vlen; /* Length returned by asprintf(). */
480 +
481 + /*
482 + * Set vfmt. If vfmt_buf may not be big enough,
483 + * malloc() space, taking care to free it later.
484 + */
485 + if (&fmt[-1] - pct < sizeof(vfmt_buf))
486 + vfmt = vfmt_buf;
487 + else
488 + vfmt = (char *)malloc(&fmt[-1] - pct + 1);
489 +
490 + /* Set the separator character, if not specified. */
491 + if (vsep == 'X') {
492 + if (ch == 'c')
493 + vsep = '\0';
494 + else
495 + vsep = ' ';
496 + }
497 +
498 + /* Create the format specifier. */
499 + for (i = j = 0; i < &fmt[-1] - pct; i++) {
500 + switch (pct[i]) {
501 + case ',': case ';': case ':': case '_':
502 + case 'v': case 'h': case 'l':
503 + /* Ignore. */
504 + break;
505 + case '*':
506 + if (pct[i - 1] != '.')
507 + vwidth = 1;
508 + else
509 + vprec = 1;
510 + /* FALLTHROUGH */
511 + default:
512 + vfmt[j++] = pct[i];
513 + }
514 + }
515 +
516 + /*
517 + * Determine the number of elements in the vector and
518 + * finish up the format specifier.
519 + */
520 + if (flags & SHORTINT) {
521 + vfmt[j++] = 'h';
522 + vcnt = 8;
523 + } else if (flags & LONGINT) {
524 + vfmt[j++] = 'l';
525 + vcnt = 4;
526 + } else {
527 + switch (ch) {
528 + case 'a':
529 + case 'A':
530 + case 'e':
531 + case 'E':
532 + case 'f':
533 + case 'g':
534 + case 'G':
535 + vcnt = 4;
536 + break;
537 + default:
538 + /*
539 + * The default case should never
540 + * happen.
541 + */
542 + case 'c':
543 + case 'd':
544 + case 'i':
545 + case 'u':
546 + case 'o':
547 + case 'p':
548 + case 'x':
549 + case 'X':
550 + vcnt = 16;
551 + }
552 + }
553 + vfmt[j++] = ch;
554 + vfmt[j++] = '\0';
555 +
556 +/* Get a vector element. */
557 +#define VPRINT(cnt, ind, args...) do { \
558 + if (flags & FPT) { \
559 + velm.f = vval.vfloatarg[ind]; \
560 + vlen = asprintf(&vstr, vfmt , ## args, velm.f); \
561 + } else { \
562 + switch (cnt) { \
563 + default: \
564 + /* The default case should never happen. */ \
565 + case 4: \
566 + velm.i = (unsigned)vval.vintarg[ind]; \
567 + break; \
568 + case 8: \
569 + velm.i = (unsigned short)vval.vshortarg[ind]; \
570 + break; \
571 + case 16: \
572 + velm.i = (unsigned char)vval.vchararg[ind]; \
573 + break; \
574 + } \
575 + vlen = asprintf(&vstr, vfmt , ## args, velm.i); \
576 + } \
577 + ret += vlen; \
578 + PRINT(vstr, vlen); \
579 + free(vstr); \
580 +} while (0)
581 +
582 + /* Actually print. */
583 + if (vwidth == 0) {
584 + if (vprec == 0) {
585 + /* First element. */
586 + VPRINT(vcnt, 0);
587 + for (i = 1; i < vcnt; i++) {
588 + /* Separator. */
589 + if (vsep)
590 + PRINT(&vsep, 1);
591 +
592 + /* Element. */
593 + VPRINT(vcnt, i);
594 + }
595 + } else {
596 + /* First element. */
597 + VPRINT(vcnt, 0, prec);
598 + for (i = 1; i < vcnt; i++) {
599 + /* Separator. */
600 + if (vsep)
601 + PRINT(&vsep, 1);
602 +
603 + /* Element. */
604 + VPRINT(vcnt, i, prec);
605 + }
606 + }
607 + } else {
608 + if (vprec == 0) {
609 + /* First element. */
610 + VPRINT(vcnt, 0, width);
611 + for (i = 1; i < vcnt; i++) {
612 + /* Separator. */
613 + if (vsep)
614 + PRINT(&vsep, 1);
615 +
616 + /* Element. */
617 + VPRINT(vcnt, i, width);
618 + }
619 + } else {
620 + /* First element. */
621 + VPRINT(vcnt, 0, width, prec);
622 + for (i = 1; i < vcnt; i++) {
623 + /* Separator. */
624 + if (vsep)
625 + PRINT(&vsep, 1);
626 +
627 + /* Element. */
628 + VPRINT(vcnt, i, width, prec);
629 + }
630 + }
631 + }
632 +#undef VPRINT
633 +
634 + if (vfmt != vfmt_buf)
635 + free(vfmt);
636 +
637 + continue;
638 + }
639 +#endif /* ALTIVEC */
640 /*
641 * All reasonable formats wind up here. At this point, `cp'
642 * points to a string which (if not flags&LADJUST) should be
643 @@ -1109,7 +1484,7 @@
644 realsz = dprec > size ? dprec : size;
645 if (sign)
646 realsz++;
647 - else if (ox[1])
648 + if (ox[1])
649 realsz += 2;
650
651 prsize = width > realsz ? width : realsz;
652 @@ -1123,9 +1498,9 @@
653 PAD(width - realsz, blanks);
654
655 /* prefix */
656 - if (sign) {
657 + if (sign)
658 PRINT(&sign, 1);
659 - } else if (ox[1]) { /* ox[1] is either x, X, or \0 */
660 + if (ox[1]) { /* ox[1] is either x, X, or \0 */
661 ox[0] = '0';
662 PRINT(ox, 2);
663 }
664 @@ -1368,6 +1743,11 @@
665 if (flags & LONGINT)
666 ADDTYPE(T_WINT);
667 else
668 +#ifdef ALTIVEC
669 + if (flags & VECTOR)
670 + ADDTYPE(T_VECTOR);
671 + else
672 +#endif /* ALTIVEC */
673 ADDTYPE(T_INT);
674 break;
675 case 'D':
676 @@ -1387,6 +1767,11 @@
677 case 'f':
678 case 'g':
679 case 'G':
680 +#ifdef ALTIVEC
681 + if (flags & VECTOR)
682 + ADDTYPE(T_VECTOR);
683 + else
684 +#endif /* ALTIVEC */
685 if (flags & LONGDBL)
686 ADDTYPE(T_LONG_DOUBLE);
687 else
688 @@ -1415,9 +1800,19 @@
689 flags |= LONGINT;
690 /*FALLTHROUGH*/
691 case 'o':
692 +#ifdef ALTIVEC
693 + if (flags & VECTOR)
694 + ADDTYPE(T_VECTOR);
695 + else
696 +#endif /* ALTIVEC */
697 ADDUARG();
698 break;
699 case 'p':
700 +#ifdef ALTIVEC
701 + if (flags & VECTOR)
702 + ADDTYPE(T_VECTOR);
703 + else
704 +#endif /* ALTIVEC */
705 ADDTYPE(TP_VOID);
706 break;
707 case 'S':
708 @@ -1435,6 +1830,11 @@
709 case 'u':
710 case 'X':
711 case 'x':
712 +#ifdef ALTIVEC
713 + if (flags & VECTOR)
714 + ADDTYPE(T_VECTOR);
715 + else
716 +#endif /* ALTIVEC */
717 ADDUARG();
718 break;
719 default: /* "%?" prints ?, unless ? is NUL */
720 @@ -1520,6 +1920,12 @@
721 (*argtable) [n].longdoublearg = va_arg (ap, long double);
722 break;
723 #endif
724 +#ifdef ALTIVEC
725 + case T_VECTOR:
726 + if (hasAltivec)
727 + ap = getvec( &((*argtable) [n]), NULL, 0, ap );
728 + break;
729 +#endif /* ALTIVEC */
730 case TP_CHAR:
731 (*argtable) [n].pchararg = va_arg (ap, char *);
732 break;
mirror of libc