![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to read.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / bin / src|
Return to read.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / bin / src |
1.1 root 1: /*
2: *-IMPORTS:
3: * <sys/compat.h>
4: * USE_PROTO
5: * LOCAL
6: * ARGS ()
7: * <limits.h>
8: * LONG_MAX
9: * LONG_MIN
10: * ULONG_MAX
11: * <string.h>
12: * memchr ()
13: * "buildobj.h"
14: * BUILD_OK
15: * build_t
16: * builder_alloc ()
17: * build_addchar ()
18: * build_begin ()
19: * build_end ()
20: * build_error ()
21: * build_release ()
22: * "ehand.h"
23: * ehand_t
24: * CHAIN_ERROR ()
25: * POP_HANDLER ()
26: * PUSH_HANDLER ()
27: * throw_error ()
28: * "input.h"
29: * IN_EOF
30: * input_t
31: * "lex.h"
32: * CLASS_FLUSH
33: * CLASS_SEP
34: * lex_t
35: * classify ()
36: */
37:
38: #include <sys/compat.h>
39: #include <limits.h>
40: #include <string.h>
41:
42: #include "buildobj.h"
43: #include "ehand.h"
44: #include "input.h"
45: #include "lex.h"
46:
47: #include "read.h"
48:
49:
50: /*
51: * Simple glue functions to encapsulate the input system.
52: */
53:
54: #if USE_PROTO
55: int (read_char) (input_t * input)
56: #else
57: int
58: read_char ARGS ((input))
59: input_t * input;
60: #endif
61: {
62: if (input == NULL)
63: throw_error ("NULL parameter passed to read_char ()");
64:
65: return (* input->in_read) (input);
66: }
67:
68:
69: #if USE_PROTO
70: void (unread_char) (input_t * input)
71: #else
72: void
73: unread_char ARGS ((input))
74: input_t * input;
75: #endif
76: {
77: if (input == NULL)
78: throw_error ("NULL parameter passed to unread_char ()");
79:
80: (* input->in_unread) (input);
81: }
82:
83:
84: #if USE_PROTO
85: void (read_error) (input_t * input)
86: #else
87: void
88: read_error ARGS ((input))
89: input_t * input;
90: #endif
91: {
92: if (input == NULL)
93: throw_error ("NULL parameter passed to read_error ()");
94:
95: (* input->in_error) (input);
96: }
97:
98:
99: #if USE_PROTO
100: void (read_close) (input_t * input)
101: #else
102: void
103: read_close ARGS ((input))
104: input_t * input;
105: #endif
106: {
107: if (input == NULL)
108: throw_error ("NULL parameter passed to read_close ()");
109:
110: (* input->in_close) (input);
111: }
112:
113:
114: /*
115: * Simple helper to ensure that we don't bump into EOF or EOL too early.
116: */
117:
118: #if USE_PROTO
119: void (check_not_eol) (int ch)
120: #else
121: void
122: check_not_eol ARGS ((ch))
123: int ch;
124: #endif
125: {
126: if (ch == '\n')
127: throw_error ("premature end of line");
128:
129: if (ch == READ_EOF)
130: throw_error ("premature end of input");
131: }
132:
133:
134: /*
135: * We use this function to eat anything that the lexical specification
136: * considers flushable until we see an end-of-line or end-of-file.
137: */
138:
139: #if USE_PROTO
140: int (expect_eol) (input_t * input, lex_t * lexp, int ch)
141: #else
142: int
143: expect_eol ARGS ((input, lexp, ch))
144: input_t * input;
145: lex_t * lexp;
146: int ch;
147: #endif
148: {
149: if (ch != '\n' && ch != READ_EOF)
150: while ((ch = (* input->in_read) (input)) != '\n') {
151:
152: if (ch == IN_EOF)
153: return READ_EOF;
154:
155: if (classify (lexp, ch, 1) != CLASS_FLUSH)
156: break;
157: }
158:
159: return ch;
160: }
161:
162:
163: /*
164: * Read a token from a file; this function may use the subclassed version to
165: * support more efficient tokenization if possible.
166: *
167: * Note that we don't null-terminate the data or do any other funky stuff. If
168: * our caller wants to to that, well that's fine, and we don't finish the
169: * object so that the caller can extend it. Note that by returning the token
170: * length that we built, this function can be used to incrementally extend
171: * variable-length data and allow the positions of the subparts to be properly
172: * recovered.
173: */
174:
175: #if USE_PROTO
176: int (read_token) (input_t * input, lex_t * lexp, build_t * heap,
177: token_t * tokenp)
178: #else
179: int
180: read_token ARGS ((input, lexp, heap, tokenp))
181: input_t * input;
182: lex_t * lexp;
183: build_t * heap;
184: token_t * tokenp;
185: #endif
186: {
187: int ch;
188: int err;
189:
190: if (input == NULL || lexp == NULL || heap == NULL || tokenp == NULL)
191: throw_error ("invalid parameters in read_token ()");
192:
193: if (input->in_readtok != NULL) {
194: /*
195: * Use the subclassed version. Since we won't actually be
196: * building the token on the passed-in heap, terminate the
197: * current build on that heap.
198: */
199:
200: build_end (heap, NULL);
201:
202: tokenp->tok_heap = NULL;
203: tokenp->tok_data = (* input->in_readtok) (input, lexp,
204: & tokenp->tok_len);
205:
206: return (* input->in_read) (input);
207: }
208:
209:
210: tokenp->tok_heap = heap;
211: tokenp->tok_data = NULL;
212: tokenp->tok_len = 0;
213:
214: for (;;) {
215: if ((ch = (* input->in_read) (input)) == IN_EOF)
216: return ch;
217:
218: switch (classify (lexp, ch, tokenp->tok_len == 0)) {
219:
220: case CLASS_FLUSH:
221: continue;
222:
223: case CLASS_SEP:
224: return ch;
225:
226: default:
227: break;
228: }
229:
230:
231: /*
232: * We have read a valid non-separator character, add it to the
233: * current input symbol.
234: */
235:
236: tokenp->tok_len ++;
237:
238: if ((err = build_addchar (heap, ch)) != BUILD_OK)
239: throw_error ("build_addchar () reported %d (%s)", err,
240: build_error (err));
241: }
242: }
243:
244:
245: /*
246: * Handy function for clients of read_token () to finish up any build-heap
247: * allocation in the usual case where read_token () is simply expected to copy
248: * data to the heap.
249: *
250: * If it was adding data to the heap, add a NULL terminator for the usual case
251: * where we would also like the object to be useable as a string.
252: */
253:
254: #if USE_PROTO
255: void (token_end) (token_t * tok)
256: #else
257: void
258: token_end ARGS ((tok))
259: token_t * tok;
260: #endif
261: {
262: char null;
263:
264: if (tok->tok_heap == NULL)
265: return;
266:
267: null = 0;
268:
269: if (tok->tok_len != 0 ?
270: (build_add (tok->tok_heap, 1, & null) != 0) ||
271: (tok->tok_data =
272: build_end (tok->tok_heap, NULL)) == NULL :
273: build_end (tok->tok_heap, NULL) != NULL)
274: throw_error ("Error ending token construction");
275: }
276:
277:
278: /*
279: * In the case where a token was able to be scanned in-place, it is often
280: * necessary to copy it to a heap, even if only temporarily. As with the above
281: * token_end, we terminate the token as if it was a string.
282: *
283: * If the token is actually in a different heap from the one given, we move it
284: * to the new heap. This works in with some special behaviour in the build
285: * system where object building can be temporarily suspended, allowing some
286: * kinds of recursive operations to work on borrowed heap space.
287: */
288:
289: #if USE_PROTO
290: void (token_copy) (token_t * tok, build_t * heap)
291: #else
292: void
293: token_copy ARGS ((tok, heap))
294: token_t * tok;
295: build_t * heap;
296: #endif
297: {
298: char null;
299: unsigned char * data;
300: int err;
301:
302: if (tok->tok_heap == heap)
303: return;
304:
305: null = 0;
306:
307: if ((err = build_begin (heap, tok->tok_len, tok->tok_data)) != 0 ||
308: (err = build_add (heap, 1, & null)) != 0 ||
309: (err = BUILD_NO_OBJECT,
310: (data = build_end (heap, NULL)) == NULL))
311: throw_error ("Cannot copy token data to heap, %s",
312: build_error (err));
313:
314: if (tok->tok_heap != NULL &&
315: (err = build_release (heap, tok->tok_data)) != 0)
316: throw_error ("Cannot release data from old heap, %s",
317: build_error (err));
318:
319: tok->tok_data = data;
320: tok->tok_heap = heap;
321: }
322:
323:
324: /*
325: * If a read token has been found to be not needed, it may be discarded with
326: * this function. If it was copied to a heap, then the heap memory is
327: * released.
328: */
329:
330: #if USE_PROTO
331: void (token_discard) (token_t * tok)
332: #else
333: void
334: token_discard ARGS ((tok))
335: token_t * tok;
336: #endif
337: {
338: int err;
339:
340: if (tok->tok_heap != NULL &&
341: (err = build_release (tok->tok_heap, tok->tok_data)) != 0)
342: throw_error ("Cannot release token data, error %s",
343: build_error (err));
344: }
345:
346:
347: /*
348: * Simply discard flushable input until the next non-flushable input
349: * character.
350: */
351:
352: #if USE_PROTO
353: void (read_flush) (input_t * input, lex_t * lexp)
354: #else
355: void
356: read_flush ARGS ((input, lexp))
357: input_t * input;
358: lex_t * lexp;
359: #endif
360: {
361: int ch;
362:
363: while ((ch = (* input->in_read) (input)) != IN_EOF) {
364:
365: if (classify (lexp, ch, 1) != CLASS_FLUSH) {
366:
367: (* input->in_unread) (input);
368: break;
369: }
370: }
371: }
372:
373:
374: /*
375: * To help with the numeric conversions, here we define a simple conversion
376: * utility that converts a character to a digit independent of character set
377: * and digit case.
378: *
379: * ... a truly general way of doing this would be nice ... maybe some kind of
380: * virtual-machine interpreter would be up to it ... hmmm.
381: */
382:
383: enum {
384: NOT_DIGIT = -1
385: };
386:
387: #if USE_PROTO
388: LOCAL int (char_to_digit) (int ch, int radix)
389: #else
390: LOCAL int
391: char_to_digit ARGS ((ch, radix))
392: int ch;
393: int radix;
394: #endif
395: {
396: static CONST char digits [] = {
397: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
398: 'A', 'B', 'C', 'D', 'E', 'F',
399: 'a', 'b', 'c', 'd', 'e', 'f'
400: };
401: static CONST char values [sizeof (digits)] = {
402: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
403: 10, 11, 12, 13, 14, 15,
404: 10, 11, 12, 13, 14, 15
405: };
406: CONST char * temp;
407:
408:
409: if ((temp = (CONST char *) memchr (digits, ch,
410: sizeof (digits))) == NULL ||
411: (ch = values [temp - digits]) >= radix)
412: return -1;
413:
414: return ch;
415: }
416:
417:
418: /*
419: * Both read_ulong () and read_long () need to be able to select a radix for
420: * the number in question based on an explicit radix prefix. This code does
421: * that for both functions; under certain circumstances, the numeric input
422: * might be completed by this code.
423: */
424:
425: #if USE_PROTO
426: LOCAL int (choose_radix) (input_t * input, unsigned long * ulongp,
427: int * radixp)
428: #else
429: LOCAL int
430: choose_radix ARGS ((input, ulongp, radixp))
431: input_t * input;
432: unsigned long * ulongp;
433: int * radixp;
434: #endif
435: {
436: int ch;
437: int errflag;
438:
439: * ulongp = 0;
440:
441: /*
442: * Perform a radix-selection step, looking for 0, 1-9, 0X, or 0x as
443: * indications of what radix to read the rest of the number in.
444: */
445:
446: switch (ch = (* input->in_read) (input)) {
447:
448: case IN_EOF:
449: return 1;
450:
451: case '0': /* octal or hexadecimal */
452: switch (ch = (* input->in_read) (input)) {
453:
454: case IN_EOF:
455: return 1;
456:
457: case 'x':
458: case 'X':
459: /*
460: * For the case of radix-16 numbers with an explicit
461: * radix in the text, we have a special error case,
462: * consisting of an 0x or 0X followed by something
463: * that is not a valid digit.
464: *
465: * The easiest way to test for this is to try
466: * converting the first digit right here.
467: */
468:
469: * radixp = 16;
470: errflag = -1;
471:
472: if ((ch = (* input->in_read) (input))
473: == IN_EOF)
474: return -1;
475: break;
476:
477: default:
478: * radixp = 8;
479: errflag = 1;
480: break;
481: }
482: break;
483:
484: default:
485: * radixp = 10;
486: errflag = 0;
487: break;
488: }
489:
490:
491: /*
492: * The need for the extra error check required by hexadecimal numbers
493: * could have made life difficult for the caller in terms of working
494: * out whether this function actually began reading a number or not.
495: *
496: * To simplify this, we ensure that this function always consumes at
497: * least the first digit. Of course, the actual response to the next
498: * character not being a valid digit is different in each case, so we
499: * also deal with that.
500: */
501:
502: if ((ch = char_to_digit (ch, * radixp)) == -1) {
503:
504: (* input->in_unread) (input);
505: return errflag;
506: }
507:
508: * ulongp = ch;
509: return 0;
510: }
511:
512:
513: /*
514: * Read an unsigned long number from the input. No initial whitespace is
515: * skipped, no sign character is permitted, and the first value that is not
516: * valid for a number of the given radix ends conversion.
517: *
518: * If "radix" is 0, the usual C radix specifiers are recognized. This version
519: * of the code has a maximum "radix" value of 16.
520: *
521: * A return value of 0 indicates no number was seen, a return value of -1
522: * indicates an invalid number was seen (such as 0xZ, or a number that is too
523: * large to be represented accurately with an unsigned long), and a return
524: * value of 1 indicates a number was successfully read.
525: */
526:
527: #if USE_PROTO
528: int (read_ulong) (input_t * input, unsigned long * ulongp, int radix)
529: #else
530: int
531: read_ulong ARGS ((input, ulongp, radix))
532: input_t * input;
533: unsigned long * ulongp;
534: int radix;
535: #endif
536: {
537: char ch;
538: unsigned long temp;
539: unsigned long radix_max;
540: int read_something;
541:
542: if (input == NULL || ulongp == NULL || radix < 0 || radix > 16)
543: throw_error ("Invalid parameter passed to read_ulong ()");
544:
545: * ulongp = 0;
546:
547: if (radix == 0) {
548:
549: switch (ch = choose_radix (input, ulongp, & radix)) {
550:
551: case 0:
552: break;
553:
554: default:
555: return ch;
556: }
557:
558: read_something = 1;
559: } else
560: read_something = 0;
561:
562: /*
563: * In order to detect overflow portably, we figure out the smallest
564: * value that will cause overflow when multiplied by the radix, and
565: * test against that before the multiplication. If the addition of the
566: * value of "ch" causes overflow, that can be detected by a value of
567: * "temp" that is smaller after the addition, according to the rules
568: * of ANSI/ISO unsigned arithmetic. Note that unsigned overflow is
569: * required to be non-signalling in an ANSI/ISO environment.
570: */
571:
572: temp = * ulongp;
573: radix_max = ULONG_MAX / radix;
574:
575: for (;;) {
576:
577: if ((ch = (* input->in_read) (input)) == IN_EOF)
578: break;
579:
580: if ((ch = char_to_digit (ch, radix)) == -1) {
581:
582: (* input->in_unread) (input);
583: break;
584: }
585:
586: if (temp > radix_max) {
587: /*
588: * Will overflow during the multiplication.
589: */
590:
591: read_something = -1;
592: temp = ULONG_MAX;
593:
594: continue;
595: }
596:
597: read_something = 1;
598: temp = (temp * radix) + ch;
599:
600: if (temp < ch) {
601: /*
602: * Overflowed during the addition.
603: */
604:
605: read_something = -1;
606: temp = ULONG_MAX;
607:
608: continue;
609: }
610: }
611:
612: * ulongp = temp;
613:
614: return read_something;
615: }
616:
617:
618: /*
619: * Read a signed long number from the input. No initial whitespace is skipped,
620: * and the sign character must immediately precede the digits of the number
621: * (or the redix specifier), and the first value that is not valid for a
622: * number of the given radix ends conversion.
623: *
624: * If "radix" is 0, the usual C radix specifiers are recognized. This version
625: * of the code has a maximum "radix" value of 16.
626: *
627: * A return value of 0 indicates no number was seen, a return value of -1
628: * indicates an invalid number was seen (such as 0xZ, or a number that is too
629: * large to be represented accurately with a signed long), and a return value
630: * of 1 indicates a number was successfully read.
631: */
632:
633: #if USE_PROTO
634: int (read_long) (input_t * input, long * longp, int radix)
635: #else
636: int
637: read_long ARGS ((input, longp, radix))
638: input_t * input;
639: long * longp;
640: int radix;
641: #endif
642: {
643: int ch;
644: unsigned long temp;
645: int sign;
646:
647: /*
648: * To save time and effort, we simply test for an initial sign flag,
649: * use read_ulong () to convert a number, and then range check the
650: * result before converting it to signed form.
651: */
652:
653: switch (ch = (* input->in_read) (input)) {
654:
655: case IN_EOF:
656: return 1;
657:
658: case '-':
659: sign = -1;
660: break;
661:
662: case '+':
663: sign = 1;
664: break;
665:
666: default:
667: /*
668: * There is no sign character that we can see, return the
669: * lookahead character to the input source so that it will be
670: * checked by read_ulong ().
671: */
672:
673: sign = 0;
674: (* input->in_unread) (input);
675: }
676:
677: ch = read_ulong (input, & temp, radix);
678:
679:
680: /*
681: * Before we range-check the result that we are going to return, it
682: * pays to note that the range of signed numbers may well not be
683: * symmetric. Typically, there are more negative numbers than non-zero
684: * positive numbers, so that "- LONG_MIN" is not a legal long integer.
685: *
686: * Producing a value of LONG_MIN without getting into implementation-
687: * defined (or undefined, in K&R) territory is tricky because of the
688: * integral promotions. We'll work around it by subtracting from -1
689: * rather than zero.
690: *
691: * We'd better test that the range of negative integers is at most one
692: * greater than the range of non-zero positive integers. We can't do
693: * the test if the preprocessor does arithmetic wrong, though, and
694: * many do.
695: */
696:
697: #if -23UL > 0
698: # if (- (LONG_MIN + 0UL)) - 1 > LONG_MAX
699: # error There are too many negative integers!
700: # endif
701: #else
702: /* Your preprocessor does arithmetic wrong */
703: #endif
704:
705:
706: if (sign < 0 && temp != 0) {
707:
708: temp -= 1;
709:
710: if (temp > - (unsigned long) LONG_MIN - 1) {
711:
712: * longp = LONG_MIN;
713: return -1;
714: } else
715: * longp = -1 - (long) temp;
716:
717: } else if (temp > LONG_MAX) {
718:
719: * longp = LONG_MAX;
720: return -1;
721: } else
722: * longp = temp;
723:
724:
725: /*
726: * If we saw a sign (of either kind) and nothing else, that's an
727: * error.
728: */
729:
730: return (sign != 0 && ch == 0) ? -1 : ch;
731: }
732:
733:
734: /*
735: * Read a single unsigned long or a numeric range (indicated by a pair of
736: * unsigned longs separated by a hyphen without any intervening whitespace).
737: */
738:
739: #if USE_PROTO
740: int (read_ulongs) (input_t * input, lex_t * lexp, unsigned long * number,
741: int rangeflag)
742: #else
743: int
744: read_ulongs ARGS ((input, lexp, number, rangeflag))
745: input_t * input;
746: lex_t * lexp;
747: unsigned long * number;
748: int rangeflag;
749: #endif
750: {
751: if ((rangeflag != RANGE && rangeflag != NO_RANGE) ||
752: input == NULL || lexp == NULL || number == NULL)
753: throw_error ("Invalid parameter to read_ulongs ()");
754:
755: /*
756: * We permit initial whitespace according to the current lexical
757: * idea of what whitespace is.
758: */
759:
760: read_flush (input, lexp);
761:
762: if (read_ulong (input, number, 0) != 1)
763: throw_error ("Illegal unsigned long number");
764:
765: if (rangeflag == RANGE) {
766: int ch;
767:
768: if ((ch = (* input->in_read) (input)) != IN_EOF &&
769: ((* input->in_unread) (input), /* for effect */
770: ch == '-')) {
771: /*
772: * Read the second part of the range.
773: */
774:
775: if (read_ulong (input, number + 1, 0) != 1)
776: throw_error ("Illegal second half of unsigned long range");
777: } else
778: number [1] = number [0];
779: }
780:
781: return (* input->in_read) (input);
782: }
783:
784:
785: /*
786: * Read a single integer or a numeric range (indicated by a pair of integers
787: * separated by a hyphen without any intervening whitespace).
788: */
789:
790: #if USE_PROTO
791: int (read_ints) (input_t * input, lex_t * lexp, int * number, int rangeflag)
792: #else
793: int
794: read_ints ARGS ((input, lexp, number, rangeflag))
795: input_t * input;
796: lex_t * lexp;
797: int * number;
798: int rangeflag;
799: #endif
800: {
801: long value;
802:
803: if ((rangeflag != RANGE && rangeflag != NO_RANGE) ||
804: input == NULL || lexp == NULL || number == NULL)
805: throw_error ("Invalid parameter to read_ints ()");
806:
807: /*
808: * We permit initial whitespace according to the current lexical
809: * idea of what whitespace is.
810: */
811:
812: read_flush (input, lexp);
813:
814: if (read_long (input, & value, 0) != 1 ||
815: #ifdef __COHERENT__
816: 0) /* Coherent compiles the test below to bad code */
817: #else
818: value > INT_MAX || value < INT_MIN)
819: #endif
820: throw_error ("Illegal integer number");
821:
822: number [0] = (int) value;
823:
824: if (rangeflag == RANGE) {
825: int ch;
826:
827: if ((ch = (* input->in_read) (input)) != IN_EOF &&
828: ((* input->in_unread) (input), /* for effect */
829: ch == '-')) {
830: /*
831: * Read the second part of the range.
832: */
833:
834: if (read_long (input, & value, 0) != 1 ||
835: #ifdef __COHERENT__
836: 0) /* Coherent compiles to bad code */
837: #else
838: value > INT_MAX || value < INT_MIN)
839: #endif
840: throw_error ("Illegal second half of integer range");
841: }
842:
843: number [1] = (int) value;
844: }
845:
846: return (* input->in_read) (input);
847: }
848:
849:
850: /*
851: * Read a single integer or a numeric range (indicated by a pair of integers
852: * separated by a hyphen without any intervening whitespace).
853: */
854:
855: #if USE_PROTO
856: int (read_longs) (input_t * input, lex_t * lexp, long * number, int rangeflag)
857: #else
858: int
859: read_longs ARGS ((input, lexp, number, rangeflag))
860: input_t * input;
861: lex_t * lexp;
862: long * number;
863: int rangeflag;
864: #endif
865: {
866: if ((rangeflag != RANGE && rangeflag != NO_RANGE) ||
867: input == NULL || lexp == NULL || number == NULL)
868: throw_error ("Invalid parameter to read_longs ()");
869:
870: /*
871: * We permit initial whitespace according to the current lexical
872: * idea of what whitespace is.
873: */
874:
875: read_flush (input, lexp);
876:
877: if (read_long (input, number, 0) != 1)
878: throw_error ("Illegal long-integer number");
879:
880: if (rangeflag == RANGE) {
881: int ch;
882:
883: if ((ch = (* input->in_read) (input)) != IN_EOF &&
884: ((* input->in_unread) (input), /* for effect */
885: ch == '-')) {
886: /*
887: * Read the second part of the range.
888: */
889:
890: if (read_long (input, number + 1, 0) != 1)
891: throw_error ("Illegal second half of long-integer range");
892: }
893: }
894:
895: return (* input->in_read) (input);
896: }
897:
898:
899: /*
900: * Read a single unsigned integer or a numeric range (indicated by a pair of
901: * unsigned integers separated by a hyphen without any intervening
902: * whitespace).
903: */
904:
905: #if USE_PROTO
906: int (read_uints) (input_t * input, lex_t * lexp, unsigned int * number,
907: int rangeflag)
908: #else
909: int
910: read_uints ARGS ((input, lexp, number, rangeflag))
911: input_t * input;
912: lex_t * lexp;
913: unsigned int * number;
914: int rangeflag;
915: #endif
916: {
917: unsigned long value;
918:
919: if ((rangeflag != RANGE && rangeflag != NO_RANGE) ||
920: input == NULL || lexp == NULL || number == NULL)
921: throw_error ("Invalid parameter to read_ints ()");
922:
923: /*
924: * We permit initial whitespace according to the current lexical
925: * idea of what whitespace is.
926: */
927:
928: read_flush (input, lexp);
929:
930: if (read_ulong (input, & value, 0) != 1 || value > UINT_MAX)
931: throw_error ("Illegal unsigned integer number");
932:
933: number [0] = (unsigned int) value;
934:
935: if (rangeflag == RANGE) {
936: int ch;
937:
938: if ((ch = (* input->in_read) (input)) != IN_EOF &&
939: ((* input->in_unread) (input), /* for effect */
940: ch == '-')) {
941: /*
942: * Read the second part of the range.
943: */
944:
945: if (read_ulong (input, & value, 0) != 1 ||
946: value > UINT_MAX)
947: throw_error ("Illegal second half of unsigned integer range");
948: }
949:
950: number [1] = (unsigned int) value;
951: }
952:
953: return (* input->in_read) (input);
954: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.