![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fmt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / jove|
Return to fmt.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / jove |
1.1 root 1: /*************************************************************************
2: * This program is copyright (C) 1985, 1986 by Jonathan Payne. It is *
3: * provided to you without charge for use only on a licensed Unix *
4: * system. You may copy JOVE provided that this notice is included with *
5: * the copy. You may not sell copies of this program or versions *
6: * modified for use on microcomputer systems, unless the copies are *
7: * included with a Unix system distribution and the source is provided. *
8: *************************************************************************/
9:
10: #include "jove.h"
11: #include "io.h"
12: #include "termcap.h"
13:
14: #include <varargs.h>
15:
16: char mesgbuf[MESG_SIZE];
17:
18: /* VARARGS2 */
19:
20: format(buf, len, fmt, ap)
21: char *buf,
22: *fmt;
23: va_list ap;
24: {
25: File strbuf,
26: *sp = &strbuf;
27:
28: sp->f_ptr = sp->f_base = buf;
29: sp->f_fd = -1; /* Not legit for files */
30: sp->f_cnt = len;
31: sp->f_flags = F_STRING;
32: sp->f_bufsize = len;
33:
34: doformat(sp, fmt, ap);
35: putc('\0', sp);
36: }
37:
38: static char padc = ' ';
39: static File *curiop = 0;
40:
41: static
42: PPchar(c, str)
43: int c;
44: char *str;
45: {
46: char *cp = str;
47:
48: if (c == '\033')
49: strcpy(cp, "ESC");
50: else if (c < ' ')
51: sprintf(cp, "C-%c", c + '@');
52: else if (c == '\177')
53: strcpy(cp, "^?");
54: else
55: sprintf(cp, "%c", c);
56: }
57:
58: static
59: putld(leftadj, width, d, base)
60: long d;
61: {
62: int length = 1;
63: long tmpd = d;
64:
65: while (tmpd = (tmpd / base))
66: length++;
67: if (d < 0)
68: length++;
69: if (!leftadj)
70: pad(padc, width - length);
71: if (d < 0) {
72: putc('-', curiop);
73: d = -d;
74: }
75: outld(d, base);
76: if (leftadj)
77: pad(padc, width - length);
78: }
79:
80: static
81: outld(d, base)
82: long d;
83: {
84: long n;
85:
86: if (n = (d / base))
87: outld(n, base);
88: putc((int) ('0' + (int) (d % base)), curiop);
89: }
90:
91: static
92: puts(leftadj, width, str)
93: char *str;
94: {
95: int length;
96: register char *cp,
97: c;
98:
99: if (str == 0)
100: #if pyr
101: str = "";
102: #else
103: str = "(null)";
104: #endif
105: length = strlen(str);
106: cp = str;
107: if (!leftadj)
108: pad(' ', width - length);
109: while (c = *cp++)
110: putc(c, curiop);
111: if (leftadj)
112: pad(' ', width - length);
113: }
114:
115: static
116: pad(c, amount)
117: register int c,
118: amount;
119: {
120: while (--amount >= 0)
121: putc(c, curiop);
122: }
123:
124: static
125: doformat(sp, fmt, ap)
126: register File *sp;
127: register char *fmt;
128: va_list ap;
129: {
130: register char c;
131: int leftadj,
132: width;
133: File *pushiop = curiop;
134:
135: curiop = sp;
136:
137: while (c = *fmt++) {
138: if (c != '%') {
139: putc(c, sp);
140: continue;
141: }
142:
143: padc = ' ';
144: leftadj = width = 0;
145: c = *fmt++;
146: if (c == '-') {
147: leftadj++;
148: c = *fmt++;
149: }
150: if (c == '0') {
151: padc = '0';
152: c = *fmt++;
153: }
154: while (c >= '0' && c <= '9') {
155: width = width * 10 + (c - '0');
156: c = *fmt++;
157: }
158: if (c == '*') {
159: width = va_arg(ap, int);
160: c = *fmt++;
161: }
162: reswitch:
163: /* At this point, fmt points at one past the format letter. */
164: switch (c) {
165: case 'l':
166: c = Upper(*++fmt);
167: goto reswitch;
168:
169: case '%':
170: putc('%', curiop);
171: break;
172:
173: case 'o':
174: putld(leftadj, width, (long) va_arg(ap, int), 8);
175: break;
176:
177: case 'd':
178: putld(leftadj, width, (long) va_arg(ap, int), 10);
179: break;
180:
181: case 'D':
182: putld(leftadj, width, va_arg(ap, long), 10);
183: break;
184:
185: case 'p':
186: {
187: char cbuf[20];
188:
189: PPchar(va_arg(ap, int), cbuf);
190: puts(leftadj, width, cbuf);
191: break;
192: }
193:
194: case 'n':
195: if (va_arg(ap, int) != 1)
196: puts(leftadj, width, "s");
197: break;
198:
199: case 's':
200: puts(leftadj, width, va_arg(ap, char *));
201: break;
202:
203: case 'c':
204: putc(va_arg(ap, int), curiop);
205: break;
206:
207: case 'f': /* current command name gets inserted here! */
208: puts(leftadj, width, LastCmd->Name);
209: break;
210:
211: default:
212: complain("%%%c?", c);
213: }
214: }
215: curiop = pushiop;
216: }
217:
218: /* VARARGS1 */
219:
220: char *
221: sprint(fmt, va_alist)
222: char *fmt;
223: va_dcl
224: {
225: va_list ap;
226: static char line[100];
227:
228: va_start(ap);
229: format(line, sizeof line, fmt, ap);
230: va_end(ap);
231: return line;
232: }
233:
234: /* VARARGS1 */
235:
236: printf(fmt, va_alist)
237: char *fmt;
238: va_dcl
239: {
240: va_list ap;
241:
242: va_start(ap);
243: doformat(stdout, fmt, ap);
244: va_end(ap);
245: }
246:
247: /* VARARGS1 */
248:
249: fprintf(fp, fmt, va_alist)
250: File *fp;
251: char *fmt;
252: va_dcl
253: {
254: va_list ap;
255:
256: va_start(ap);
257: doformat(fp, fmt, ap);
258: va_end(ap);
259: }
260:
261: /* VARARGS2 */
262:
263: sprintf(str, fmt, va_alist)
264: char *str,
265: *fmt;
266: va_dcl
267: {
268: va_list ap;
269:
270: va_start(ap);
271: format(str, 130, fmt, ap);
272: va_end(ap);
273: }
274:
275: /* VARARGS1 */
276:
277: s_mess(fmt, va_alist)
278: char *fmt;
279: va_dcl
280: {
281: va_list ap;
282:
283: if (InJoverc)
284: return;
285: va_start(ap);
286: format(mesgbuf, sizeof mesgbuf, fmt, ap);
287: va_end(ap);
288: message(mesgbuf);
289: }
290:
291: /* VARARGS1 */
292:
293: f_mess(fmt, va_alist)
294: char *fmt;
295: va_dcl
296: {
297: va_list ap;
298:
299: va_start(ap);
300: format(mesgbuf, sizeof mesgbuf, fmt, ap);
301: va_end(ap);
302: DrawMesg(NO);
303: UpdMesg++; /* Still needs updating (for convenience) */
304: }
305:
306: /* VARARGS1 */
307:
308: add_mess(fmt, va_alist)
309: char *fmt;
310: va_dcl
311: {
312: int mesg_len = strlen(mesgbuf);
313: va_list ap;
314:
315: if (InJoverc)
316: return;
317: va_start(ap);
318: format(&mesgbuf[mesg_len], (sizeof mesgbuf) - mesg_len, fmt, ap);
319: va_end(ap);
320: message(mesgbuf);
321: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.