![[BACK]](/icons/back.gif){kind=icon}
Return to inout.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / dc|
Return to inout.c CVS log | Up to [local] / src / usr.bin / dc |
1.23 ! guenther 1: /* $OpenBSD: inout.c,v 1.22 2021/11/10 04:39:16 tb Exp $ */
1.1 otto 2:
3: /*
4: * Copyright (c) 2003, Otto Moerbeek <otto@drijf.net>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include <ctype.h>
20: #include <err.h>
21: #include <string.h>
22:
23: #include "extern.h"
24:
1.11 otto 25: #define MAX_CHARS_PER_LINE 68
1.1 otto 26:
1.12 otto 27: static int lastchar;
28: static int charcount;
1.1 otto 29:
30: static int src_getcharstream(struct source *);
1.14 otto 31: static void src_ungetcharstream(struct source *);
1.1 otto 32: static char *src_getlinestream(struct source *);
33: static void src_freestream(struct source *);
34: static int src_getcharstring(struct source *);
1.14 otto 35: static void src_ungetcharstring(struct source *);
1.1 otto 36: static char *src_getlinestring(struct source *);
37: static void src_freestring(struct source *);
1.12 otto 38: static void flushwrap(FILE *);
1.1 otto 39: static void putcharwrap(FILE *, int);
40: static void printwrap(FILE *, const char *);
41: static char *get_digit(u_long, int, u_int);
42:
43: static struct vtable stream_vtable = {
44: src_getcharstream,
45: src_ungetcharstream,
46: src_getlinestream,
47: src_freestream
48: };
49:
50: static struct vtable string_vtable = {
51: src_getcharstring,
52: src_ungetcharstring,
53: src_getlinestring,
54: src_freestring
55: };
56:
57: void
58: src_setstream(struct source *src, FILE *stream)
59: {
60: src->u.stream = stream;
61: src->vtable = &stream_vtable;
62: }
63:
64: void
65: src_setstring(struct source *src, char *p)
66: {
67: src->u.string.buf = (u_char *)p;
68: src->u.string.pos = 0;
69: src->vtable = &string_vtable;
70: }
71:
72: static int
73: src_getcharstream(struct source *src)
74: {
75: return src->lastchar = getc(src->u.stream);
76: }
77:
1.14 otto 78: static void
1.1 otto 79: src_ungetcharstream(struct source *src)
80: {
1.14 otto 81: (void)ungetc(src->lastchar, src->u.stream);
1.1 otto 82: }
83:
84: static void
85: src_freestream(struct source *src)
86: {
87: }
88:
89: static char *
90: src_getlinestream(struct source *src)
91: {
92: char buf[BUFSIZ];
93:
94: if (fgets(buf, BUFSIZ, src->u.stream) == NULL)
95: return bstrdup("");
96: return bstrdup(buf);
97: }
98:
99: static int
100: src_getcharstring(struct source *src)
101: {
102: src->lastchar = src->u.string.buf[src->u.string.pos];
103: if (src->lastchar == '\0')
104: return EOF;
105: else {
106: src->u.string.pos++;
107: return src->lastchar;
108: }
109: }
110:
1.14 otto 111: static void
1.1 otto 112: src_ungetcharstring(struct source *src)
113: {
1.7 otto 114: if (src->u.string.pos > 0) {
115: if (src->lastchar != '\0')
116: --src->u.string.pos;
1.14 otto 117: }
1.1 otto 118: }
119:
120: static char *
121: src_getlinestring(struct source *src)
122: {
123: char buf[BUFSIZ];
124: int ch, i;
125:
126: i = 0;
127: while (i < BUFSIZ-1) {
128: ch = src_getcharstring(src);
129: if (ch == EOF)
130: break;
131: buf[i++] = ch;
132: if (ch == '\n')
133: break;
134: }
135: buf[i] = '\0';
136: return bstrdup(buf);
137: }
138:
139: static void
140: src_freestring(struct source *src)
141: {
142: free(src->u.string.buf);
143: }
144:
145: static void
1.12 otto 146: flushwrap(FILE *f)
147: {
148: if (lastchar != -1)
1.14 otto 149: (void)putc(lastchar, f);
1.12 otto 150: }
151:
152: static void
1.1 otto 153: putcharwrap(FILE *f, int ch)
154: {
1.12 otto 155: if (charcount >= MAX_CHARS_PER_LINE) {
156: charcount = 0;
1.14 otto 157: (void)fputs("\\\n", f);
1.1 otto 158: }
1.12 otto 159: if (lastchar != -1) {
160: charcount++;
1.14 otto 161: (void)putc(lastchar, f);
1.12 otto 162: }
163: lastchar = ch;
1.1 otto 164: }
165:
166: static void
167: printwrap(FILE *f, const char *p)
168: {
169: char buf[12];
170: char *q = buf;
171:
1.14 otto 172: (void)strlcpy(buf, p, sizeof(buf));
1.1 otto 173: while (*q)
174: putcharwrap(f, *q++);
175: }
176:
177: struct number *
178: readnumber(struct source *src, u_int base)
179: {
180: struct number *n;
181: int ch;
182: bool sign = false;
183: bool dot = false;
184: BN_ULONG v;
1.13 otto 185: u_int i;
1.1 otto 186:
187: n = new_number();
1.20 otto 188: bn_check(BN_set_word(n->number, 0));
1.1 otto 189:
190: while ((ch = (*src->vtable->readchar)(src)) != EOF) {
191:
192: if ('0' <= ch && ch <= '9')
193: v = ch - '0';
194: else if ('A' <= ch && ch <= 'F')
195: v = ch - 'A' + 10;
196: else if (ch == '_') {
197: sign = true;
198: continue;
199: } else if (ch == '.') {
200: if (dot)
201: break;
202: dot = true;
203: continue;
204: } else {
205: (*src->vtable->unreadchar)(src);
206: break;
207: }
208: if (dot)
209: n->scale++;
210:
211: bn_check(BN_mul_word(n->number, base));
212:
1.8 otto 213: #if 0
1.1 otto 214: /* work around a bug in BN_add_word: 0 += 0 is buggy.... */
215: if (v > 0)
1.8 otto 216: #endif
1.1 otto 217: bn_check(BN_add_word(n->number, v));
1.13 otto 218: }
219: if (base != 10) {
220: scale_number(n->number, n->scale);
221: for (i = 0; i < n->scale; i++)
1.14 otto 222: (void)BN_div_word(n->number, base);
1.1 otto 223: }
224: if (sign)
225: negate(n);
226: return n;
227: }
228:
229: char *
230: read_string(struct source *src)
231: {
1.4 otto 232: int count, i, sz, new_sz, ch;
1.1 otto 233: char *p;
1.5 otto 234: bool escape;
1.1 otto 235:
1.5 otto 236: escape = false;
1.1 otto 237: count = 1;
238: i = 0;
239: sz = 15;
240: p = bmalloc(sz + 1);
241:
242: while ((ch = (*src->vtable->readchar)(src)) != EOF) {
1.5 otto 243: if (!escape) {
244: if (ch == '[')
245: count++;
246: else if (ch == ']')
247: count--;
248: if (count == 0)
249: break;
250: }
251: if (ch == '\\' && !escape)
252: escape = true;
253: else {
254: escape = false;
255: if (i == sz) {
256: new_sz = sz * 2;
1.18 deraadt 257: p = breallocarray(p, 1, new_sz + 1);
1.5 otto 258: sz = new_sz;
259: }
260: p[i++] = ch;
1.1 otto 261: }
262: }
263: p[i] = '\0';
264: return p;
265: }
266:
267: static char *
268: get_digit(u_long num, int digits, u_int base)
269: {
270: char *p;
1.3 deraadt 271:
1.1 otto 272: if (base <= 16) {
273: p = bmalloc(2);
1.2 deraadt 274: p[0] = num >= 10 ? num + 'A' - 10 : num + '0';
1.1 otto 275: p[1] = '\0';
276: } else {
277: if (asprintf(&p, "%0*lu", digits, num) == -1)
1.6 otto 278: err(1, NULL);
1.1 otto 279: }
280: return p;
281: }
282:
283: void
284: printnumber(FILE *f, const struct number *b, u_int base)
285: {
286: struct number *int_part, *fract_part;
287: int digits;
288: char buf[11];
289: size_t sz;
290: int i;
291: struct stack stack;
292: char *p;
293:
1.12 otto 294: charcount = 0;
295: lastchar = -1;
1.1 otto 296: if (BN_is_zero(b->number))
297: putcharwrap(f, '0');
298:
299: int_part = new_number();
300: fract_part = new_number();
301: fract_part->scale = b->scale;
302:
303: if (base <= 16)
304: digits = 1;
305: else {
306: digits = snprintf(buf, sizeof(buf), "%u", base-1);
307: }
308: split_number(b, int_part->number, fract_part->number);
309:
310: i = 0;
311: stack_init(&stack);
312: while (!BN_is_zero(int_part->number)) {
313: BN_ULONG rem = BN_div_word(int_part->number, base);
314: stack_pushstring(&stack, get_digit(rem, digits, base));
315: i++;
316: }
317: sz = i;
1.16 otto 318: if (BN_is_negative(b->number))
1.1 otto 319: putcharwrap(f, '-');
320: for (i = 0; i < sz; i++) {
321: p = stack_popstring(&stack);
322: if (base > 16)
323: putcharwrap(f, ' ');
324: printwrap(f, p);
325: free(p);
326: }
327: stack_clear(&stack);
328: if (b->scale > 0) {
329: struct number *num_base;
1.22 tb 330: BIGNUM *mult, *stop;
1.1 otto 331:
332: putcharwrap(f, '.');
333: num_base = new_number();
1.14 otto 334: bn_check(BN_set_word(num_base->number, base));
1.22 tb 335: mult = BN_new();
336: bn_checkp(mult);
337: bn_check(BN_one(mult));
338: stop = BN_new();
339: bn_checkp(stop);
340: bn_check(BN_one(stop));
341: scale_number(stop, b->scale);
1.1 otto 342:
343: i = 0;
1.22 tb 344: while (BN_cmp(mult, stop) < 0) {
1.1 otto 345: u_long rem;
346:
347: if (i && base > 16)
348: putcharwrap(f, ' ');
349: i = 1;
350:
1.17 otto 351: bmul_number(fract_part, fract_part, num_base,
352: bmachine_scale());
1.1 otto 353: split_number(fract_part, int_part->number, NULL);
354: rem = BN_get_word(int_part->number);
355: p = get_digit(rem, digits, base);
356: int_part->scale = 0;
357: normalize(int_part, fract_part->scale);
1.14 otto 358: bn_check(BN_sub(fract_part->number, fract_part->number,
359: int_part->number));
1.1 otto 360: printwrap(f, p);
361: free(p);
1.22 tb 362: bn_check(BN_mul_word(mult, base));
1.1 otto 363: }
364: free_number(num_base);
1.22 tb 365: BN_free(mult);
366: BN_free(stop);
1.1 otto 367: }
1.12 otto 368: flushwrap(f);
1.1 otto 369: free_number(int_part);
370: free_number(fract_part);
371: }
372:
373: void
374: print_value(FILE *f, const struct value *value, const char *prefix, u_int base)
375: {
1.14 otto 376: (void)fputs(prefix, f);
1.1 otto 377: switch (value->type) {
378: case BCODE_NONE:
379: if (value->array != NULL)
1.14 otto 380: (void)fputs("<array>", f);
1.1 otto 381: break;
382: case BCODE_NUMBER:
383: printnumber(f, value->u.num, base);
384: break;
385: case BCODE_STRING:
1.14 otto 386: (void)fputs(value->u.string, f);
1.1 otto 387: break;
388: }
389: }
390:
391: void
392: print_ascii(FILE *f, const struct number *n)
393: {
394: int numbits, i, ch;
395:
1.21 otto 396: numbits = BN_num_bytes(n->number) * 8;
1.1 otto 397: while (numbits > 0) {
398: ch = 0;
399: for (i = 0; i < 8; i++)
1.21 otto 400: ch |= BN_is_bit_set(n->number, numbits-i-1) << (7 - i);
1.14 otto 401: (void)putc(ch, f);
1.1 otto 402: numbits -= 8;
403: }
404: }