开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
vfscanf.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：18k
源码类别：

MySQL数据库

开发平台：

Visual C++

vfscanf.c：源码内容
  1. /*-
  2.  * Copyright (c) 1990 The Regents of the University of California.
  3.  * Copyright (c) 1993, 1994 Chris Provenzano. 
  4.  * All rights reserved.
  5.  *
  6.  * This code is derived from software contributed to Berkeley by
  7.  * Chris Torek.
  8.  *
  9.  * Redistribution and use in source and binary forms, with or without
  10.  * modification, are permitted provided that the following conditions
  11.  * are met:
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer.
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in the
  16.  *    documentation and/or other materials provided with the distribution.
  17.  * 3. All advertising materials mentioning features or use of this software
  18.  *    must display the following acknowledgement:
  19.  * This product includes software developed by the University of
  20.  * California, Berkeley and its contributors.
  21.  * 4. Neither the name of the University nor the names of its contributors
  22.  *    may be used to endorse or promote products derived from this software
  23.  *    without specific prior written permission.
  24.  *
  25.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35.  * SUCH DAMAGE.
  36.  */
  38. #if defined(LIBC_SCCS) && !defined(lint)
  39. /*static char *sccsid = "from: @(#)vfscanf.c 5.7 (Berkeley) 12/14/92";*/
  40. static char *rcsid = "$Id$";
  41. #endif /* LIBC_SCCS and not lint */
  43. #include <stdio.h>
  44. #include <stdlib.h>
  45. #include <ctype.h>
  46. #if __STDC__
  47. #include <stdarg.h>
  48. #else
  49. #include <varargs.h>
  50. #endif
  51. #include "local.h"
  53. #define FLOATING_POINT
  55. #include "floatio.h"
  56. #define BUF 513 /* Maximum length of numeric string. */
  58. /*
  59.  * Flags used during conversion.
  60.  */
  61. #define LONG 0x01 /* l: long or double */
  62. #define LONGDBL 0x02 /* L: long double; unimplemented */
  63. #define SHORT 0x04 /* h: short */
  64. #define SUPPRESS 0x08 /* suppress assignment */
  65. #define POINTER 0x10 /* weird %p pointer (`fake hex') */
  66. #define NOSKIP 0x20 /* do not skip blanks */
  68. /*
  69.  * The following are used in numeric conversions only:
  70.  * SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;
  71.  * SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.
  72.  */
  73. #define SIGNOK 0x40 /* +/- is (still) legal */
  74. #define NDIGITS 0x80 /* no digits detected */
  76. #define DPTOK 0x100 /* (float) decimal point is still legal */
  77. #define EXPOK 0x200 /* (float) exponent (e+3, etc) still legal */
  79. #define PFXOK 0x100 /* 0x prefix is (still) legal */
  80. #define NZDIGITS 0x200 /* no zero digits detected */
  82. /*
  83.  * Conversion types.
  84.  */
  85. #define CT_CHAR 0 /* %c conversion */
  86. #define CT_CCL 1 /* %[...] conversion */
  87. #define CT_STRING 2 /* %s conversion */
  88. #define CT_INT 3 /* integer, i.e., strtol or strtoul */
  89. #define CT_FLOAT 4 /* floating, i.e., strtod */
  91. #define u_char unsigned char
  92. #define u_long unsigned long
  94. static u_char *__sccl();
  96. /*
  97.  * vfscanf
  98.  */
  99. __svfscanf(fp, fmt0, ap)
  100. register FILE *fp;
  101. char const *fmt0;
  102. pthread_va_list ap;
  103. {
  104. register u_char *fmt = (u_char *)fmt0;
  105. register int c; /* character from format, or conversion */
  106. register size_t width; /* field width, or 0 */
  107. register char *p; /* points into all kinds of strings */
  108. register int n; /* handy integer */
  109. register int flags; /* flags as defined above */
  110. register char *p0; /* saves original value of p when necessary */
  111. int nassigned; /* number of fields assigned */
  112. int nread; /* number of characters consumed from fp */
  113. int base; /* base argument to strtol/strtoul */
  114. u_long (*ccfn)(); /* conversion function (strtol/strtoul) */
  115. char ccltab[256]; /* character class table for %[...] */
  116. char buf[BUF]; /* buffer for numeric conversions */
  118. /* `basefix' is used to avoid `if' tests in the integer scanner */
  119. static short basefix[17] =
  120. { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
  122. nassigned = 0;
  123. nread = 0;
  124. base = 0; /* XXX just to keep gcc happy */
  125. ccfn = NULL; /* XXX just to keep gcc happy */
  126. for (;;) {
  127. c = *fmt++;
  128. if (c == 0)
  129. return (nassigned);
  130. if (isspace(c)) {
  131. for (;;) {
  132. if (fp->_r <= 0 && __srefill(fp))
  133. return (nassigned);
  134. if (!isspace(*fp->_p))
  135. break;
  136. nread++, fp->_r--, fp->_p++;
  137. }
  138. continue;
  139. }
  140. if (c != '%')
  141. goto literal;
  142. width = 0;
  143. flags = 0;
  144. /*
  145.  * switch on the format.  continue if done;
  146.  * break once format type is derived.
  147.  */
  148. again: c = *fmt++;
  149. switch (c) {
  150. case '%':
  151. literal:
  152. if (fp->_r <= 0 && __srefill(fp))
  153. goto input_failure;
  154. if (*fp->_p != c)
  155. goto match_failure;
  156. fp->_r--, fp->_p++;
  157. nread++;
  158. continue;
  160. case '*':
  161. flags |= SUPPRESS;
  162. goto again;
  163. case 'l':
  164. flags |= LONG;
  165. goto again;
  166. case 'L':
  167. flags |= LONGDBL;
  168. goto again;
  169. case 'h':
  170. flags |= SHORT;
  171. goto again;
  173. case '0': case '1': case '2': case '3': case '4':
  174. case '5': case '6': case '7': case '8': case '9':
  175. width = width * 10 + c - '0';
  176. goto again;
  178. /*
  179.  * Conversions.
  180.  * Those marked `compat' are for 4.[123]BSD compatibility.
  181.  *
  182.  * (According to ANSI, E and X formats are supposed
  183.  * to the same as e and x.  Sorry about that.)
  184.  */
  185. case 'D': /* compat */
  186. flags |= LONG;
  187. /* FALLTHROUGH */
  188. case 'd':
  189. c = CT_INT;
  190. ccfn = (u_long (*)())strtol;
  191. base = 10;
  192. break;
  194. case 'i':
  195. c = CT_INT;
  196. ccfn = (u_long (*)())strtol;
  197. base = 0;
  198. break;
  200. case 'O': /* compat */
  201. flags |= LONG;
  202. /* FALLTHROUGH */
  203. case 'o':
  204. c = CT_INT;
  205. ccfn = strtoul;
  206. base = 8;
  207. break;
  209. case 'u':
  210. c = CT_INT;
  211. ccfn = strtoul;
  212. base = 10;
  213. break;
  215. case 'X': /* compat   XXX */
  216. flags |= LONG;
  217. /* FALLTHROUGH */
  218. case 'x':
  219. flags |= PFXOK; /* enable 0x prefixing */
  220. c = CT_INT;
  221. ccfn = strtoul;
  222. base = 16;
  223. break;
  225. #ifdef FLOATING_POINT
  226. case 'E': /* compat   XXX */
  227. case 'F': /* compat */
  228. flags |= LONG;
  229. /* FALLTHROUGH */
  230. case 'e': case 'f': case 'g':
  231. c = CT_FLOAT;
  232. break;
  233. #endif
  235. case 's':
  236. c = CT_STRING;
  237. break;
  239. case '[':
  240. fmt = __sccl(ccltab, fmt);
  241. flags |= NOSKIP;
  242. c = CT_CCL;
  243. break;
  245. case 'c':
  246. flags |= NOSKIP;
  247. c = CT_CHAR;
  248. break;
  250. case 'p': /* pointer format is like hex */
  251. flags |= POINTER | PFXOK;
  252. c = CT_INT;
  253. ccfn = strtoul;
  254. base = 16;
  255. break;
  257. case 'n':
  258. if (flags & SUPPRESS) /* ??? */
  259. continue;
  260. if (flags & SHORT)
  261. *va_arg(ap, short *) = nread;
  262. else if (flags & LONG)
  263. *va_arg(ap, long *) = nread;
  264. else
  265. *va_arg(ap, int *) = nread;
  266. continue;
  268. /*
  269.  * Disgusting backwards compatibility hacks. XXX
  270.  */
  271. case '': /* compat */
  272. return (EOF);
  274. default: /* compat */
  275. if (isupper(c))
  276. flags |= LONG;
  277. c = CT_INT;
  278. ccfn = (u_long (*)())strtol;
  279. base = 10;
  280. break;
  281. }
  283. /*
  284.  * We have a conversion that requires input.
  285.  */
  286. if (fp->_r <= 0 && __srefill(fp))
  287. goto input_failure;
  289. /*
  290.  * Consume leading white space, except for formats
  291.  * that suppress this.
  292.  */
  293. if ((flags & NOSKIP) == 0) {
  294. while (isspace(*fp->_p)) {
  295. nread++;
  296. if (--fp->_r > 0)
  297. fp->_p++;
  298. else if (__srefill(fp))
  299. goto input_failure;
  300. }
  301. /*
  302.  * Note that there is at least one character in
  303.  * the buffer, so conversions that do not set NOSKIP
  304.  * ca no longer result in an input failure.
  305.  */
  306. }
  308. /*
  309.  * Do the conversion.
  310.  */
  311. switch (c) {
  313. case CT_CHAR:
  314. /* scan arbitrary characters (sets NOSKIP) */
  315. if (width == 0)
  316. width = 1;
  317. if (flags & SUPPRESS) {
  318. size_t sum = 0;
  319. for (;;) {
  320. if ((n = fp->_r) < width) {
  321. sum += n;
  322. width -= n;
  323. fp->_p += n;
  324. if (__srefill(fp)) {
  325. if (sum == 0)
  326.     goto input_failure;
  327. break;
  328. }
  329. } else {
  330. sum += width;
  331. fp->_r -= width;
  332. fp->_p += width;
  333. break;
  334. }
  335. }
  336. nread += sum;
  337. } else {
  338. size_t r = fread((void *)va_arg(ap, char *), 1,
  339.     width, fp);
  341. if (r == 0)
  342. goto input_failure;
  343. nread += r;
  344. nassigned++;
  345. }
  346. break;
  348. case CT_CCL:
  349. /* scan a (nonempty) character class (sets NOSKIP) */
  350. if (width == 0)
  351. width = ~0; /* `infinity' */
  352. /* take only those things in the class */
  353. if (flags & SUPPRESS) {
  354. n = 0;
  355. while (ccltab[*fp->_p]) {
  356. n++, fp->_r--, fp->_p++;
  357. if (--width == 0)
  358. break;
  359. if (fp->_r <= 0 && __srefill(fp)) {
  360. if (n == 0)
  361. goto input_failure;
  362. break;
  363. }
  364. }
  365. if (n == 0)
  366. goto match_failure;
  367. } else {
  368. p0 = p = va_arg(ap, char *);
  369. while (ccltab[*fp->_p]) {
  370. fp->_r--;
  371. *p++ = *fp->_p++;
  372. if (--width == 0)
  373. break;
  374. if (fp->_r <= 0 && __srefill(fp)) {
  375. if (p == p0)
  376. goto input_failure;
  377. break;
  378. }
  379. }
  380. n = p - p0;
  381. if (n == 0)
  382. goto match_failure;
  383. *p = 0;
  384. nassigned++;
  385. }
  386. nread += n;
  387. break;
  389. case CT_STRING:
  390. /* like CCL, but zero-length string OK, & no NOSKIP */
  391. if (width == 0)
  392. width = ~0;
  393. if (flags & SUPPRESS) {
  394. n = 0;
  395. while (!isspace(*fp->_p)) {
  396. n++, fp->_r--, fp->_p++;
  397. if (--width == 0)
  398. break;
  399. if (fp->_r <= 0 && __srefill(fp))
  400. break;
  401. }
  402. nread += n;
  403. } else {
  404. p0 = p = va_arg(ap, char *);
  405. while (!isspace(*fp->_p)) {
  406. fp->_r--;
  407. *p++ = *fp->_p++;
  408. if (--width == 0)
  409. break;
  410. if (fp->_r <= 0 && __srefill(fp))
  411. break;
  412. }
  413. *p = 0;
  414. nread += p - p0;
  415. nassigned++;
  416. }
  417. continue;
  419. case CT_INT:
  420. /* scan an integer as if by strtol/strtoul */
  421. #ifdef hardway
  422. if (width == 0 || width > sizeof(buf) - 1)
  423. width = sizeof(buf) - 1;
  424. #else
  425. /* size_t is unsigned, hence this optimisation */
  426. if (--width > sizeof(buf) - 2)
  427. width = sizeof(buf) - 2;
  428. width++;
  429. #endif
  430. flags |= SIGNOK | NDIGITS | NZDIGITS;
  431. for (p = buf; width; width--) {
  432. c = *fp->_p;
  433. /*
  434.  * Switch on the character; `goto ok'
  435.  * if we accept it as a part of number.
  436.  */
  437. switch (c) {
  439. /*
  440.  * The digit 0 is always legal, but is
  441.  * special.  For %i conversions, if no
  442.  * digits (zero or nonzero) have been
  443.  * scanned (only signs), we will have
  444.  * base==0.  In that case, we should set
  445.  * it to 8 and enable 0x prefixing.
  446.  * Also, if we have not scanned zero digits
  447.  * before this, do not turn off prefixing
  448.  * (someone else will turn it off if we
  449.  * have scanned any nonzero digits).
  450.  */
  451. case '0':
  452. if (base == 0) {
  453. base = 8;
  454. flags |= PFXOK;
  455. }
  456. if (flags & NZDIGITS)
  457.     flags &= ~(SIGNOK|NZDIGITS|NDIGITS);
  458. else
  459.     flags &= ~(SIGNOK|PFXOK|NDIGITS);
  460. goto ok;
  462. /* 1 through 7 always legal */
  463. case '1': case '2': case '3':
  464. case '4': case '5': case '6': case '7':
  465. base = basefix[base];
  466. flags &= ~(SIGNOK | PFXOK | NDIGITS);
  467. goto ok;
  469. /* digits 8 and 9 ok iff decimal or hex */
  470. case '8': case '9':
  471. base = basefix[base];
  472. if (base <= 8)
  473. break; /* not legal here */
  474. flags &= ~(SIGNOK | PFXOK | NDIGITS);
  475. goto ok;
  477. /* letters ok iff hex */
  478. case 'A': case 'B': case 'C':
  479. case 'D': case 'E': case 'F':
  480. case 'a': case 'b': case 'c':
  481. case 'd': case 'e': case 'f':
  482. /* no need to fix base here */
  483. if (base <= 10)
  484. break; /* not legal here */
  485. flags &= ~(SIGNOK | PFXOK | NDIGITS);
  486. goto ok;
  488. /* sign ok only as first character */
  489. case '+': case '-':
  490. if (flags & SIGNOK) {
  491. flags &= ~SIGNOK;
  492. goto ok;
  493. }
  494. break;
  496. /* x ok iff flag still set & 2nd char */
  497. case 'x': case 'X':
  498. if (flags & PFXOK && p == buf + 1) {
  499. base = 16; /* if %i */
  500. flags &= ~PFXOK;
  501. goto ok;
  502. }
  503. break;
  504. }
  506. /*
  507.  * If we got here, c is not a legal character
  508.  * for a number.  Stop accumulating digits.
  509.  */
  510. break;
  511. ok:
  512. /*
  513.  * c is legal: store it and look at the next.
  514.  */
  515. *p++ = c;
  516. if (--fp->_r > 0)
  517. fp->_p++;
  518. else if (__srefill(fp))
  519. break; /* EOF */
  520. }
  521. /*
  522.  * If we had only a sign, it is no good; push
  523.  * back the sign.  If the number ends in `x',
  524.  * it was [sign] '0' 'x', so push back the x
  525.  * and treat it as [sign] '0'.
  526.  */
  527. if (flags & NDIGITS) {
  528. if (p > buf)
  529. (void) ungetc(*(u_char *)--p, fp);
  530. goto match_failure;
  531. }
  532. c = ((u_char *)p)[-1];
  533. if (c == 'x' || c == 'X') {
  534. --p;
  535. (void) ungetc(c, fp);
  536. }
  537. if ((flags & SUPPRESS) == 0) {
  538. u_long res;
  540. *p = 0;
  541. res = (*ccfn)(buf, (char **)NULL, base);
  542. if (flags & POINTER)
  543. *va_arg(ap, void **) = (void *)res;
  544. else if (flags & SHORT)
  545. *va_arg(ap, short *) = res;
  546. else if (flags & LONG)
  547. *va_arg(ap, long *) = res;
  548. else
  549. *va_arg(ap, int *) = res;
  550. nassigned++;
  551. }
  552. nread += p - buf;
  553. break;
  555. #ifdef FLOATING_POINT
  556. case CT_FLOAT:
  557. /* scan a floating point number as if by strtod */
  558. #ifdef hardway
  559. if (width == 0 || width > sizeof(buf) - 1)
  560. width = sizeof(buf) - 1;
  561. #else
  562. /* size_t is unsigned, hence this optimisation */
  563. if (--width > sizeof(buf) - 2)
  564. width = sizeof(buf) - 2;
  565. width++;
  566. #endif
  567. flags |= SIGNOK | NDIGITS | DPTOK | EXPOK;
  568. for (p = buf; width; width--) {
  569. c = *fp->_p;
  570. /*
  571.  * This code mimicks the integer conversion
  572.  * code, but is much simpler.
  573.  */
  574. switch (c) {
  576. case '0': case '1': case '2': case '3':
  577. case '4': case '5': case '6': case '7':
  578. case '8': case '9':
  579. flags &= ~(SIGNOK | NDIGITS);
  580. goto fok;
  582. case '+': case '-':
  583. if (flags & SIGNOK) {
  584. flags &= ~SIGNOK;
  585. goto fok;
  586. }
  587. break;
  588. case '.':
  589. if (flags & DPTOK) {
  590. flags &= ~(SIGNOK | DPTOK);
  591. goto fok;
  592. }
  593. break;
  594. case 'e': case 'E':
  595. /* no exponent without some digits */
  596. if ((flags&(NDIGITS|EXPOK)) == EXPOK) {
  597. flags =
  598.     (flags & ~(EXPOK|DPTOK)) |
  599.     SIGNOK | NDIGITS;
  600. goto fok;
  601. }
  602. break;
  603. }
  604. break;
  605. fok:
  606. *p++ = c;
  607. if (--fp->_r > 0)
  608. fp->_p++;
  609. else if (__srefill(fp))
  610. break; /* EOF */
  611. }
  612. /*
  613.  * If no digits, might be missing exponent digits
  614.  * (just give back the exponent) or might be missing
  615.  * regular digits, but had sign and/or decimal point.
  616.  */
  617. if (flags & NDIGITS) {
  618. if (flags & EXPOK) {
  619. /* no digits at all */
  620. while (p > buf)
  621. ungetc(*(u_char *)--p, fp);
  622. goto match_failure;
  623. }
  624. /* just a bad exponent (e and maybe sign) */
  625. c = *(u_char *)--p;
  626. if (c != 'e' && c != 'E') {
  627. (void) ungetc(c, fp);/* sign */
  628. c = *(u_char *)--p;
  629. }
  630. (void) ungetc(c, fp);
  631. }
  632. if ((flags & SUPPRESS) == 0) {
  633. double res;
  635. *p = 0;
  636. res = strtod(buf, (char **) NULL);
  637. if (flags & LONG)
  638. *va_arg(ap, double *) = res;
  639. else
  640. *va_arg(ap, float *) = res;
  641. nassigned++;
  642. }
  643. nread += p - buf;
  644. break;
  645. #endif /* FLOATING_POINT */
  646. }
  647. }
  648. input_failure:
  649. return (nassigned ? nassigned : -1);
  650. match_failure:
  651. return (nassigned);
  652. }
  654. /*
  655.  * Fill in the given table from the scanset at the given format
  656.  * (just after `[').  Return a pointer to the character past the
  657.  * closing `]'.  The table has a 1 wherever characters should be
  658.  * considered part of the scanset.
  659.  */
  660. static u_char *
  661. __sccl(tab, fmt)
  662. register char *tab;
  663. register u_char *fmt;
  664. {
  665. register int c, n, v;
  667. /* first `clear' the whole table */
  668. c = *fmt++; /* first char hat => negated scanset */
  669. if (c == '^') {
  670. v = 1; /* default => accept */
  671. c = *fmt++; /* get new first char */
  672. } else
  673. v = 0; /* default => reject */
  674. /* should probably use memset here */
  675. for (n = 0; n < 256; n++)
  676. tab[n] = v;
  677. if (c == 0)
  678. return (fmt - 1);/* format ended before closing ] */
  680. /*
  681.  * Now set the entries corresponding to the actual scanset
  682.  * to the opposite of the above.
  683.  *
  684.  * The first character may be ']' (or '-') without being special;
  685.  * the last character may be '-'.
  686.  */
  687. v = 1 - v;
  688. for (;;) {
  689. tab[c] = v; /* take character c */
  690. doswitch:
  691. n = *fmt++; /* and examine the next */
  692. switch (n) {
  694. case 0: /* format ended too soon */
  695. return (fmt - 1);
  697. case '-':
  698. /*
  699.  * A scanset of the form
  700.  * [01+-]
  701.  * is defined as `the digit 0, the digit 1,
  702.  * the character +, the character -', but
  703.  * the effect of a scanset such as
  704.  * [a-zA-Z0-9]
  705.  * is implementation defined.  The V7 Unix
  706.  * scanf treats `a-z' as `the letters a through
  707.  * z', but treats `a-a' as `the letter a, the
  708.  * character -, and the letter a'.
  709.  *
  710.  * For compatibility, the `-' is not considerd
  711.  * to define a range if the character following
  712.  * it is either a close bracket (required by ANSI)
  713.  * or is not numerically greater than the character
  714.  * we just stored in the table (c).
  715.  */
  716. n = *fmt;
  717. if (n == ']' || n < c) {
  718. c = '-';
  719. break; /* resume the for(;;) */
  720. }
  721. fmt++;
  722. do { /* fill in the range */
  723. tab[++c] = v;
  724. } while (c < n);
  725. #if 1 /* XXX another disgusting compatibility hack */
  726. /*
  727.  * Alas, the V7 Unix scanf also treats formats
  728.  * such as [a-c-e] as `the letters a through e'.
  729.  * This too is permitted by the standard....
  730.  */
  731. goto doswitch;
  732. #else
  733. c = *fmt++;
  734. if (c == 0)
  735. return (fmt - 1);
  736. if (c == ']')
  737. return (fmt);
  738. #endif
  739. break;
  741. case ']': /* end of scanset */
  742. return (fmt);
  744. default: /* just another character */
  745. c = n;
  746. break;
  747. }
  748. }
  749. /* NOTREACHED */
  750. }