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