![[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.18 ! deraadt 1: /* $OpenBSD: inout.c,v 1.18 2014/12/01 13:11:21 deraadt 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 <ssl/ssl.h>
20: #include <ctype.h>
21: #include <err.h>
22: #include <string.h>
23:
24: #include "extern.h"
25:
1.11 otto 26: #define MAX_CHARS_PER_LINE 68
1.1 otto 27:
1.12 otto 28: static int lastchar;
29: static int charcount;
1.1 otto 30:
31: static int src_getcharstream(struct source *);
1.14 otto 32: static void src_ungetcharstream(struct source *);
1.1 otto 33: static char *src_getlinestream(struct source *);
34: static void src_freestream(struct source *);
35: static int src_getcharstring(struct source *);
1.14 otto 36: static void src_ungetcharstring(struct source *);
1.1 otto 37: static char *src_getlinestring(struct source *);
38: static void src_freestring(struct source *);
1.12 otto 39: static void flushwrap(FILE *);
1.1 otto 40: static void putcharwrap(FILE *, int);
41: static void printwrap(FILE *, const char *);
42: static char *get_digit(u_long, int, u_int);
43:
44: static struct vtable stream_vtable = {
45: src_getcharstream,
46: src_ungetcharstream,
47: src_getlinestream,
48: src_freestream
49: };
50:
51: static struct vtable string_vtable = {
52: src_getcharstring,
53: src_ungetcharstring,
54: src_getlinestring,
55: src_freestring
56: };
57:
58: void
59: src_setstream(struct source *src, FILE *stream)
60: {
61: src->u.stream = stream;
62: src->vtable = &stream_vtable;
63: }
64:
65: void
66: src_setstring(struct source *src, char *p)
67: {
68: src->u.string.buf = (u_char *)p;
69: src->u.string.pos = 0;
70: src->vtable = &string_vtable;
71: }
72:
73: static int
74: src_getcharstream(struct source *src)
75: {
76: return src->lastchar = getc(src->u.stream);
77: }
78:
1.14 otto 79: static void
1.1 otto 80: src_ungetcharstream(struct source *src)
81: {
1.14 otto 82: (void)ungetc(src->lastchar, src->u.stream);
1.1 otto 83: }
84:
1.14 otto 85: /* ARGSUSED */
1.1 otto 86: static void
87: src_freestream(struct source *src)
88: {
89: }
90:
91: static char *
92: src_getlinestream(struct source *src)
93: {
94: char buf[BUFSIZ];
95:
96: if (fgets(buf, BUFSIZ, src->u.stream) == NULL)
97: return bstrdup("");
98: return bstrdup(buf);
99: }
100:
101: static int
102: src_getcharstring(struct source *src)
103: {
104: src->lastchar = src->u.string.buf[src->u.string.pos];
105: if (src->lastchar == '\0')
106: return EOF;
107: else {
108: src->u.string.pos++;
109: return src->lastchar;
110: }
111: }
112:
1.14 otto 113: static void
1.1 otto 114: src_ungetcharstring(struct source *src)
115: {
1.7 otto 116: if (src->u.string.pos > 0) {
117: if (src->lastchar != '\0')
118: --src->u.string.pos;
1.14 otto 119: }
1.1 otto 120: }
121:
122: static char *
123: src_getlinestring(struct source *src)
124: {
125: char buf[BUFSIZ];
126: int ch, i;
127:
128: i = 0;
129: while (i < BUFSIZ-1) {
130: ch = src_getcharstring(src);
131: if (ch == EOF)
132: break;
133: buf[i++] = ch;
134: if (ch == '\n')
135: break;
136: }
137: buf[i] = '\0';
138: return bstrdup(buf);
139: }
140:
141: static void
142: src_freestring(struct source *src)
143: {
144: free(src->u.string.buf);
145: }
146:
147: static void
1.12 otto 148: flushwrap(FILE *f)
149: {
150: if (lastchar != -1)
1.14 otto 151: (void)putc(lastchar, f);
1.12 otto 152: }
153:
154: static void
1.1 otto 155: putcharwrap(FILE *f, int ch)
156: {
1.12 otto 157: if (charcount >= MAX_CHARS_PER_LINE) {
158: charcount = 0;
1.14 otto 159: (void)fputs("\\\n", f);
1.1 otto 160: }
1.12 otto 161: if (lastchar != -1) {
162: charcount++;
1.14 otto 163: (void)putc(lastchar, f);
1.12 otto 164: }
165: lastchar = ch;
1.1 otto 166: }
167:
168: static void
169: printwrap(FILE *f, const char *p)
170: {
171: char buf[12];
172: char *q = buf;
173:
1.14 otto 174: (void)strlcpy(buf, p, sizeof(buf));
1.1 otto 175: while (*q)
176: putcharwrap(f, *q++);
177: }
178:
179: struct number *
180: readnumber(struct source *src, u_int base)
181: {
182: struct number *n;
183: int ch;
184: bool sign = false;
185: bool dot = false;
186: BN_ULONG v;
1.13 otto 187: u_int i;
1.1 otto 188:
189: n = new_number();
190: bn_check(BN_zero(n->number));
191:
192: while ((ch = (*src->vtable->readchar)(src)) != EOF) {
193:
194: if ('0' <= ch && ch <= '9')
195: v = ch - '0';
196: else if ('A' <= ch && ch <= 'F')
197: v = ch - 'A' + 10;
198: else if (ch == '_') {
199: sign = true;
200: continue;
201: } else if (ch == '.') {
202: if (dot)
203: break;
204: dot = true;
205: continue;
206: } else {
207: (*src->vtable->unreadchar)(src);
208: break;
209: }
210: if (dot)
211: n->scale++;
212:
213: bn_check(BN_mul_word(n->number, base));
214:
1.8 otto 215: #if 0
1.1 otto 216: /* work around a bug in BN_add_word: 0 += 0 is buggy.... */
217: if (v > 0)
1.8 otto 218: #endif
1.1 otto 219: bn_check(BN_add_word(n->number, v));
1.13 otto 220: }
221: if (base != 10) {
222: scale_number(n->number, n->scale);
223: for (i = 0; i < n->scale; i++)
1.14 otto 224: (void)BN_div_word(n->number, base);
1.1 otto 225: }
226: if (sign)
227: negate(n);
228: return n;
229: }
230:
231: char *
232: read_string(struct source *src)
233: {
1.4 otto 234: int count, i, sz, new_sz, ch;
1.1 otto 235: char *p;
1.5 otto 236: bool escape;
1.1 otto 237:
1.5 otto 238: escape = false;
1.1 otto 239: count = 1;
240: i = 0;
241: sz = 15;
242: p = bmalloc(sz + 1);
243:
244: while ((ch = (*src->vtable->readchar)(src)) != EOF) {
1.5 otto 245: if (!escape) {
246: if (ch == '[')
247: count++;
248: else if (ch == ']')
249: count--;
250: if (count == 0)
251: break;
252: }
253: if (ch == '\\' && !escape)
254: escape = true;
255: else {
256: escape = false;
257: if (i == sz) {
258: new_sz = sz * 2;
1.18 ! deraadt 259: p = breallocarray(p, 1, new_sz + 1);
1.5 otto 260: sz = new_sz;
261: }
262: p[i++] = ch;
1.1 otto 263: }
264: }
265: p[i] = '\0';
266: return p;
267: }
268:
269: static char *
270: get_digit(u_long num, int digits, u_int base)
271: {
272: char *p;
1.3 deraadt 273:
1.1 otto 274: if (base <= 16) {
275: p = bmalloc(2);
1.2 deraadt 276: p[0] = num >= 10 ? num + 'A' - 10 : num + '0';
1.1 otto 277: p[1] = '\0';
278: } else {
279: if (asprintf(&p, "%0*lu", digits, num) == -1)
1.6 otto 280: err(1, NULL);
1.1 otto 281: }
282: return p;
283: }
284:
285: void
286: printnumber(FILE *f, const struct number *b, u_int base)
287: {
288: struct number *int_part, *fract_part;
289: int digits;
290: char buf[11];
291: size_t sz;
292: int i;
293: struct stack stack;
294: char *p;
295:
1.12 otto 296: charcount = 0;
297: lastchar = -1;
1.1 otto 298: if (BN_is_zero(b->number))
299: putcharwrap(f, '0');
300:
301: int_part = new_number();
302: fract_part = new_number();
303: fract_part->scale = b->scale;
304:
305: if (base <= 16)
306: digits = 1;
307: else {
308: digits = snprintf(buf, sizeof(buf), "%u", base-1);
309: }
310: split_number(b, int_part->number, fract_part->number);
311:
312: i = 0;
313: stack_init(&stack);
314: while (!BN_is_zero(int_part->number)) {
315: BN_ULONG rem = BN_div_word(int_part->number, base);
316: stack_pushstring(&stack, get_digit(rem, digits, base));
317: i++;
318: }
319: sz = i;
1.16 otto 320: if (BN_is_negative(b->number))
1.1 otto 321: putcharwrap(f, '-');
322: for (i = 0; i < sz; i++) {
323: p = stack_popstring(&stack);
324: if (base > 16)
325: putcharwrap(f, ' ');
326: printwrap(f, p);
327: free(p);
328: }
329: stack_clear(&stack);
330: if (b->scale > 0) {
331: struct number *num_base;
332: BIGNUM mult, stop;
333:
334: putcharwrap(f, '.');
335: num_base = new_number();
1.14 otto 336: bn_check(BN_set_word(num_base->number, base));
1.1 otto 337: BN_init(&mult);
1.14 otto 338: bn_check(BN_one(&mult));
1.1 otto 339: BN_init(&stop);
1.14 otto 340: bn_check(BN_one(&stop));
1.1 otto 341: scale_number(&stop, b->scale);
342:
343: i = 0;
344: while (BN_cmp(&mult, &stop) < 0) {
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.14 otto 362: bn_check(BN_mul_word(&mult, base));
1.1 otto 363: }
364: free_number(num_base);
365: BN_free(&mult);
366: BN_free(&stop);
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: BIGNUM *v;
395: int numbits, i, ch;
396:
397: v = BN_dup(n->number);
398: bn_checkp(v);
399:
1.16 otto 400: if (BN_is_negative(v))
401: BN_set_negative(v, 0);
1.1 otto 402:
403: numbits = BN_num_bytes(v) * 8;
404: while (numbits > 0) {
405: ch = 0;
406: for (i = 0; i < 8; i++)
407: ch |= BN_is_bit_set(v, numbits-i-1) << (7 - i);
1.14 otto 408: (void)putc(ch, f);
1.1 otto 409: numbits -= 8;
410: }
411: BN_free(v);
412: }