![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to agh3 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / mk|
Return to agh3 CVS log | Up to [Research Unix] / researchv10no / cmd / mk |
1.1 root 1: mkdir fio libc
2: echo fio/fioprint.c 1>&2
3: sed 's/^-//' >fio/fioprint.c <<'!'
4: -#define FIO_IMP
5: -#include <varargs.h>
6: -#include <fio.h>
7:
8: -/* VARARGS 2 */
9: -Fprint(f, fmt, va_alist)
10: int f;
11: char *fmt;
12: va_dcl
13: -{
14: - char buf[FIOBSIZE], *out;
15: - register long n;
16: - va_list ap;
17: - extern char *doprint();
18:
19: - va_start(ap);
20: - out = doprint(buf, fmt, &ap);
21: - va_end(ap);
22: - n = out-buf;
23: - if(Fwrite(f, buf, n) != n)
24: - return(-1);
25: - else
26: - return((int)n);
27: -}
28: !
29: echo libc/doprint.c 1>&2
30: sed 's/^-//' >libc/doprint.c <<'!'
31: -#include <varargs.h>
32:
33: -#define SIZE 1024
34: -#define FUNSIGN 4
35: -#define FSHORT 2
36: -#define FLONG 1
37: -#define PTR sizeof (char *)
38: -#define SHORT sizeof (int)
39: -#define INT sizeof (int)
40: -#define LONG sizeof (long)
41: -#define FLOAT sizeof (double)
42: -#define FDIGIT 30
43: -#define FDEFLT 8
44: -#define IDIGIT 40
45: -#define MAXCONV 30
46:
47: static char *out, *eout;
48: static convcount = { 13 };
49:
50: static noconv();
51: static cconv(), dconv(), hconv(), lconv();
52: static oconv(), sconv(), uconv(), xconv();
53:
54: static econv(), fconv(), gconv(), percent();
55: int printcol;
56: static
57: int (*fmtconv[MAXCONV])() =
58: -{
59: - noconv,
60: - cconv, dconv, hconv, lconv,
61: - oconv, sconv, uconv, xconv,
62: - econv, fconv, gconv, percent,
63: -};
64: static
65: char fmtindex[128] =
66: -{
67: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
68: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
69: - 0, 0, 0, 0, 0,12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
70: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
71: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
72: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
73: - 0, 0, 0, 1, 2, 9,10,11, 3, 0, 0, 0, 4, 0, 0, 5,
74: - 0, 0, 0, 6, 0, 7, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0,
75: -};
76:
77: fmtinstall(c, f)
78: char c;
79: int (*f)();
80: -{
81:
82: - c &= 0177;
83: - if(fmtindex[c] == 0) {
84: - if(convcount >= MAXCONV)
85: - return 1;
86: - fmtindex[c] = convcount++;
87: - }
88: - fmtconv[fmtindex[c]] = f;
89: - return 0;
90: -}
91:
92: char*
93: donprint(s, es, fmt, argpp)
94: char *s, *es;
95: register char *fmt;
96: va_list *argpp;
97: -{
98: - register int f1, f2, f3, sf1, c;
99: - char *sout, *seout;
100:
101: - sout = out;
102: - seout = eout;
103: - out = s;
104: - eout = es-1;
105: loop:
106: - c = *fmt++;
107: - if(c != '%') {
108: - if(c == 0) {
109: - *out = 0;
110: - s = out;
111: - out = sout;
112: - eout = seout;
113: - return s;
114: - }
115: - if(out < eout)
116: - *out++ = c;
117: - printcol++;
118: - if(c == '\n')
119: - printcol = 0; else
120: - if(c == '\t')
121: - printcol = (printcol+7) & ~7;
122: - goto loop;
123: - }
124: - f1 = 0;
125: - f2 = -1;
126: - f3 = 0;
127: - c = *fmt++;
128: - sf1 = 0;
129: - if(c == '-') {
130: - sf1 = 1;
131: - c = *fmt++;
132: - }
133: - while(c >= '0' && c <= '9') {
134: - f1 = f1*10 + c-'0';
135: - c = *fmt++;
136: - }
137: - if(sf1)
138: - f1 = -f1;
139: - if(c != '.')
140: - goto l1;
141: - c = *fmt++;
142: - while(c >= '0' && c <= '9') {
143: - if(f2 < 0)
144: - f2 = 0;
145: - f2 = f2*10 + c-'0';
146: - c = *fmt++;
147: - }
148: l1:
149: - if(c == 0)
150: - fmt--;
151: - /* NB: first arg is now a (va_list *) */
152: - c = (*fmtconv[fmtindex[c&0177]])(argpp, f1, f2, f3);
153: - if(c < 0) {
154: - f3 |= -c;
155: - c = *fmt++;
156: - goto l1;
157: - }
158: -#ifdef notdef
159: - argp += c; /* increment is now done in called routine by va_arg() */
160: -#endif
161: - goto loop;
162: -}
163:
164: numbconv(o, f1, f2, f3, b)
165: va_list *o;
166: -{
167: - char s[IDIGIT];
168: - register long v;
169: - register int i, f, n, r;
170:
171: - switch(f3 & (FLONG|FSHORT|FUNSIGN)) {
172: - case FLONG:
173: - v = va_arg(*o, long);
174: - r = LONG;
175: - break;
176:
177: - case FUNSIGN|FLONG:
178: - v = va_arg(*o, unsigned long);
179: - r = LONG;
180: - break;
181:
182: - /* NB: a (unsigned) short argument is promoted to an (unsigned) int arg. */
183: - case FSHORT:
184: - v = (short)va_arg(*o, int);
185: - r = SHORT;
186: - break;
187:
188: - case FUNSIGN|FSHORT:
189: - v = (unsigned short)va_arg(*o, unsigned);
190: - r = SHORT;
191: - break;
192:
193: - default:
194: - v = va_arg(*o, int);
195: - r = INT;
196: - break;
197:
198: - case FUNSIGN:
199: - v = va_arg(*o, unsigned);
200: - r = INT;
201: - break;
202: - }
203: - f = 0;
204: - if(!(f3 & FUNSIGN) && v < 0) {
205: - v = -v;
206: - f = 1;
207: - }
208: - s[IDIGIT-1] = 0;
209: - for(i = IDIGIT-2; i >= 1; i--) {
210: - n = (unsigned long)v % b;
211: - n += '0';
212: - if(n > '9')
213: - n += 'a' - ('9'+1);
214: - s[i] = n;
215: - v = (unsigned long)v / b;
216: - if(f2 >= 0 && i >= IDIGIT-f2)
217: - continue;
218: - if(v <= 0)
219: - break;
220: - }
221: - if(f)
222: - s[--i] = '-';
223: - strconv(s+i, f1, -1);
224: - return r;
225: -}
226:
227: char*
228: doprint(s, fmt, argp)
229: char *s, *fmt;
230: va_list *argp;
231: -{
232:
233: - return donprint(s, s+SIZE, fmt, argp);
234: -}
235:
236: -/*
237: - if you change this, change chconv
238: -*/
239:
240: strconv(o, f1, f2)
241: char *o;
242: -{
243: - register int n, c;
244: - register char *s;
245:
246: - n = 0;
247: - for(s = o; *s++;)
248: - n++;
249: - if(f1 >= 0)
250: - while(n < f1) {
251: - if(out < eout)
252: - *out++ = ' ';
253: - printcol++;
254: - n++;
255: - }
256: - for(s=o; c = *s++;)
257: - if(f2 != 0) {
258: - if(out < eout)
259: - *out++ = c;
260: - printcol++;
261: - if(c == '\n')
262: - printcol = 0; else
263: - if(c == '\t')
264: - printcol = (printcol+7) & ~7;
265: - f2--;
266: - }
267: - if(f1 < 0) {
268: - f1 = -f1;
269: - while(n < f1) {
270: - if(out < eout)
271: - *out++ = ' ';
272: - printcol++;
273: - n++;
274: - }
275: - }
276: -}
277:
278: chconv(o, f1)
279: char o;
280: -{
281: - register int n;
282:
283: - n = 1;
284: - if(f1 >= 0)
285: - while(n < f1) {
286: - if(out < eout)
287: - *out++ = ' ';
288: - printcol++;
289: - n++;
290: - }
291: - if(out < eout)
292: - *out++ = o;
293: - printcol++;
294: - if(o == '\n')
295: - printcol = 0; else
296: - if(o == '\t')
297: - printcol = (printcol+7) & ~7;
298: - if(f1 < 0) {
299: - f1 = -f1;
300: - while(n < f1) {
301: - if(out < eout)
302: - *out++ = ' ';
303: - printcol++;
304: - n++;
305: - }
306: - }
307: -}
308:
309: -/* ARGSUSED */
310: static
311: noconv(o, f1, f2, f3)
312: char *o;
313: -{
314:
315: - strconv("***", 0, -1);
316: - return 0;
317: -}
318:
319: -/* ARGSUSED */
320: static
321: cconv(o, f1, f2, f3)
322: va_list *o;
323: -{
324: - chconv((char)va_arg(*o, int), f1);
325: - return INT;
326: -}
327:
328: static
329: dconv(o, f1, f2, f3)
330: va_list *o;
331: -{
332: - int r;
333:
334: - r = numbconv(o, f1, f2, f3, 10);
335: - return r;
336: -}
337:
338: -/* ARGSUSED */
339: static
340: hconv(o, f1, f2, f3)
341: -{
342: - return -FSHORT;
343: -}
344:
345: -/* ARGSUSED */
346: static
347: lconv(o, f1, f2, f3)
348: -{
349:
350: - return -FLONG;
351: -}
352:
353: static
354: oconv(o, f1, f2, f3)
355: va_list *o;
356: -{
357: - int r;
358:
359: - r = numbconv(o, f1, f2, f3, 8);
360: - return r;
361: -}
362:
363: -/* ARGSUSED */
364: static
365: sconv(o, f1, f2, f3)
366: va_list *o;
367: -{
368:
369: - strconv(va_arg(*o, char *), f1, f2);
370: - return PTR;
371: -}
372:
373: -/* ARGSUSED */
374: static
375: uconv(o, f1, f2, f3)
376: -{
377: - return -FUNSIGN;
378: -}
379:
380: static
381: xconv(o, f1, f2, f3)
382: va_list *o;
383: -{
384: - int r;
385:
386: - r = numbconv(o, f1, f2, f3, 16);
387: - return r;
388: -}
389:
390: double pow10(), frexp();
391: -/* ARGSUSED */
392: fltconv(f, f1, f2, f3, c)
393: register double f;
394: -{
395: - char s1[FDIGIT+10], s2[FDIGIT+10];
396: - register double g;
397: - register int d, i, n, s;
398: - double h;
399: - int e;
400: - int c1, c2, c3;
401:
402: - s = 0;
403: - if(f < 0) {
404: - f = -f;
405: - s++;
406: - }
407:
408: loop:
409: - e = 0;
410: - g = 0;
411: - if(f != 0) {
412: - g = frexp(f, &e);
413: - e = e * .30103;
414: - d = e/2;
415: - h = f * pow10(-d); /* 10**-e in 2 parts */
416: - g = h * pow10(d-e);
417: - while(g < 1) {
418: - e--;
419: - g = h * pow10(d-e);
420: - }
421: - while(g >= 10) {
422: - e++;
423: - g = h * pow10(d-e);
424: - }
425: - }
426: - if(f2 < 0)
427: - f2 = FDEFLT;
428: - if(c == 'g' && f2 > 0)
429: - f2--;
430: - if(f2 > FDIGIT)
431: - f2 = FDIGIT;
432: - /*
433: - * n is number of digits to convert
434: - * 1 before, f2 after, 1 extra for rounding
435: - */
436: - n = f2 + 2;
437: - if(c == 'f') {
438: - /*
439: - * e+1 before, f2 after, 1 extra
440: - */
441: - n += e;
442: - if(n <= 0) {
443: - n = 1;
444: - g = 0;
445: - }
446: - }
447: - if(n >= FDIGIT+2) {
448: - if(c == 'e')
449: - f2 = -1;
450: - c = 'e';
451: - goto loop;
452: - }
453: - /*
454: - * convert n digits
455: - */
456: - for(i=0; i<n; i++) {
457: - d = g;
458: - if(d > g)
459: - d--;
460: - g -= d;
461: - s1[i+1] = d + '0';
462: - g *= 10;
463: - }
464: - /*
465: - * round by adding .5 into extra digit
466: - */
467: - d = 5;
468: - for(i=n-1; i>=0; i--) {
469: - s1[i+1] += d;
470: - d = 0;
471: - if(s1[i+1] > '9') {
472: - s1[i+1] -= 10;
473: - d++;
474: - }
475: - }
476: - i = 1;
477: - if(d) {
478: - s1[0] = '1';
479: - e++;
480: - i = 0;
481: - }
482: - /*
483: - * copy into final place
484: - * c1 digits of leading '0'
485: - * c2 digits from conversion
486: - * c3 digits after '.'
487: - */
488: - d = 0;
489: - if(s)
490: - s2[d++] = '-';
491: - c1 = 0;
492: - c2 = f2 + 1;
493: - c3 = f2;
494: - if(c == 'g')
495: - if(e >= -5 && e <= f2) {
496: - c1 = -e - 1;
497: - c3 = c1;
498: - if(c1 < 0)
499: - c1 = 0;
500: - c3 = f2 - e;
501: - c = 'h';
502: - }
503: - if(c == 'f') {
504: - c1 = -e;
505: - if(c1 < 0)
506: - c1 = 0;
507: - if(c1 > f2)
508: - c1 = c2;
509: - c2 += e;
510: - if(c2 < 0)
511: - c2 = 0;
512: - }
513: - while(c1 > 0) {
514: - if(c1+c2 == c3)
515: - s2[d++] = '.';
516: - s2[d++] = '0';
517: - c1--;
518: - }
519: - while(c2 > 0) {
520: - if(c1+c2 == c3)
521: - s2[d++] = '.';
522: - s2[d++] = s1[i++];
523: - c2--;
524: - }
525: - /*
526: - * strip trailing '0' on g conv
527: - */
528: - if(c == 'g' || c == 'h') {
529: - for(n=d-1; n>=0; n--)
530: - if(s2[n] != '0')
531: - break;
532: - for(i=n; i>=0; i--)
533: - if(s2[i] == '.') {
534: - d = n;
535: - if(i != n)
536: - d++;
537: - break;
538: - }
539: - }
540: - if(c == 'e' || c == 'g') {
541: - s2[d++] = 'e';
542: - s2[d++] = '+';
543: - c1 = e;
544: - if(c1 < 0) {
545: - s2[d-1] = '-';
546: - c1 = -c1;
547: - }
548: - if(c1 >= 100) {
549: - s2[d++] = c1/100 + '0';
550: - c1 %= 100;
551: - }
552: - s2[d++] = c1/10 + '0';
553: - s2[d++] = c1%10 + '0';
554: - }
555: - s2[d] = 0;
556: - strconv(s2, f1, -1);
557: - return FLOAT;
558: -}
559:
560: static
561: econv(o, f1, f2, f3)
562: va_list *o;
563: -{
564:
565: - return fltconv(va_arg(*o, double), f1, f2, f3, 'e');
566: -}
567:
568: static
569: fconv(o, f1, f2, f3)
570: va_list *o;
571: -{
572:
573: - return fltconv(va_arg(*o, double), f1, f2, f3, 'f');
574: -}
575:
576: static
577: gconv(o, f1, f2, f3)
578: va_list *o;
579: -{
580:
581: - return fltconv(va_arg(*o, double), f1, f2, f3, 'g');
582: -}
583:
584: static
585: percent()
586: -{
587:
588: - if(out < eout)
589: - *out++ = '%';
590: - return 0;
591: -}
592: !
593: echo libc/print.c 1>&2
594: sed 's/^-//' >libc/print.c <<'!'
595: -#include <varargs.h>
596:
597: -#define SIZE 1024
598: extern int printcol;
599:
600: char *doprint();
601:
602: -/* VARARGS 1 */
603: print(fmt, va_alist)
604: char *fmt;
605: va_dcl
606: -{
607: - char buf[SIZE], *out;
608: - va_list ap;
609:
610: - va_start(ap);
611: - out = doprint(buf, fmt, &ap);
612: - va_end(ap);
613: - return write(1, buf, (int)(out-buf));
614: -}
615:
616: -/* VARARGS 2 */
617: fprint(fd, fmt, va_alist)
618: char *fmt;
619: va_dcl
620: -{
621: - char buf[SIZE], *out;
622: - va_list ap;
623:
624: - va_start(ap);
625: - out = doprint(buf, fmt, &ap);
626: - va_end(ap);
627: - return write(fd, buf, (int)(out-buf));
628: -}
629:
630: -/* VARARGS 2 */
631: sprint(buf, fmt, va_alist)
632: char *buf;
633: char *fmt;
634: va_dcl
635: -{
636: - char *out;
637: - int scol;
638: - va_list ap;
639:
640: - scol = printcol;
641: - va_start(ap);
642: - out = doprint(buf, fmt, &ap);
643: - va_end(ap);
644: - printcol = scol;
645: - return out-buf;
646: -}
647: !
648:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.