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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
format.c
资源名称：cdrdao-1.1.3.src.tar.gz　[点击查看]
上传用户：weiliju62
上传日期：2007-01-06
资源大小：619k
文件大小：15k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

format.c：源码内容
  1. /* @(#)format.c 1.29 98/03/31 Copyright 1985 J. Schilling */
  2. /*
  3.  * format
  4.  * common code for printf fprintf & sprintf
  5.  *
  6.  * allows recursive printf with "%r", used in:
  7.  * error, comerr, comerrno, errmsg, errmsgno and the like
  8.  *
  9.  * Copyright (c) 1985 J. Schilling
  10.  */
  11. /*
  12.  * This program is free software; you can redistribute it and/or modify
  13.  * it under the terms of the GNU General Public License as published by
  14.  * the Free Software Foundation; either version 2, or (at your option)
  15.  * any later version.
  16.  *
  17.  * This program is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  * GNU General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU General Public License
  23.  * along with this program; see the file COPYING.  If not, write to
  24.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  */
  27. #include <mconfig.h>
  28. #include <vadefs.h>
  29. #include <strdefs.h>
  30. #include <stdxlib.h>
  31. #ifndef HAVE_STDLIB_H
  32. extern char *gcvt __PR((double, int, char *));
  33. #endif
  34. #include <standard.h>
  36. /*
  37.  * Some CPU's (e.g. PDP-11) cannot do logical shifts.
  38.  * They use rotate instead. Masking the low bits before,
  39.  * makes rotate work too.
  40.  */
  41. #define allmask(t) ((unsigned t)~((unsigned t)0))
  42. #define lowmask(t, x) ((unsigned t)~((unsigned t)((1 << (x))-1) ))
  43. #define rshiftmask(t, s)((allmask(t) & lowmask(t, s)) >> (s))
  45. #define CHARMASK makemask(char)
  46. #define SHORTMASK makemask(short)
  47. #define INTMASK makemask(int)
  48. #define LONGMASK makemask(long)
  50. #ifdef DIVLBYS
  51. extern long divlbys();
  52. extern long modlbys();
  53. #else
  54. #define divlbys(val, base) ((val)/(base))
  55. #define modlbys(val, base) ((val)%(base))
  56. #endif
  58. /*
  59.  * We use macros here to avoid the need to link to the international
  60.  * character routines.
  61.  * We don't need internationalization for our purpose.
  62.  */
  63. #define is_dig(c) (((c) >= '0') && ((c) <= '9'))
  64. #define is_cap(c) ((c) >= 'A' && (c) <= 'Z')
  65. #define to_cap(c) (is_cap(c) ? c : c - 'a' + 'A')
  66. #define cap_ty(c) (is_cap(c) ? 'L' : 'I')
  68. typedef unsigned int Uint;
  69. typedef unsigned short Ushort;
  70. typedef unsigned long Ulong;
  71. #ifdef HAVE_LONGLONG
  72. typedef unsigned long long Ullong;
  73. #endif
  75. typedef struct f_args {
  76. void (*outf) __PR((char, long)); /* Func from format(fun, arg) */
  77. long farg;     /* Arg from format (fun, arg) */
  78. int minusflag;
  79. int flags;
  80. int fldwidth;
  81. int signific;
  82. int lzero;
  83. char *buf;
  84. char *bufp;
  85. char fillc;
  86. char *prefix;
  87. int prefixlen;
  88. } f_args;
  90. #define MINUSFLG 1 /* '-' flag */
  91. #define PLUSFLG 2 /* '+' flag */
  92. #define SPACEFLG 4 /* ' ' flag */
  93. #define HASHFLG 8 /* '#' flag */
  95. LOCAL void prnum  __PR((Ulong, unsigned, f_args *));
  96. LOCAL void prdnum __PR((Ulong, f_args *));
  97. LOCAL void pronum __PR((Ulong, f_args *));
  98. LOCAL void prxnum __PR((Ulong, f_args *));
  99. LOCAL void prXnum __PR((Ulong, f_args *));
  100. LOCAL int prbuf  __PR((const char *, f_args *));
  101. LOCAL int prc    __PR((char, f_args *));
  102. LOCAL int prstring __PR((const char *, f_args *));
  105. #ifdef PROTOTYPES
  106. EXPORT int format( void (*fun)(char, long),
  107. long farg,
  108. const char *fmt,
  109. va_list args)
  110. #else
  111. EXPORT int format(fun, farg, fmt, args)
  112. register void (*fun)();
  113. register long farg;
  114. register char *fmt;
  115. va_list args;
  116. #endif
  117. {
  118. char buf[512];
  119. const char *sfmt;
  120. register int unsflag;
  121. register long val;
  122. register char type;
  123. register char mode;
  124. register char c;
  125. int count;
  126. int i;
  127. short sh;
  128. const char *str;
  129. double dval;
  130. Ulong res;
  131. char *rfmt;
  132. f_args fa;
  134. fa.outf = fun;
  135. fa.farg = farg;
  136. count = 0;
  137. /*
  138.  * Main loop over the format string.
  139.  * Increment and check for end of string is made here.
  140.  */
  141. for(; *fmt != ''; fmt++) {
  142. c = *fmt;
  143. while (c != '%') {
  144. if (c == '')
  145. return (count);
  146. (*fun)(c, farg);
  147. c = *(++fmt);
  148. count++;
  149. }
  151. /*
  152.  * We reached a '%' sign.
  153.  */
  154. buf[0] = '';
  155. fa.buf = fa.bufp = buf;
  156. fa.minusflag = 0;
  157. fa.flags = 0;
  158. fa.fldwidth = 0;
  159. fa.signific = -1;
  160. fa.lzero = 0;
  161. fa.fillc = ' ';
  162. fa.prefixlen = 0;
  163. sfmt = fmt;
  164. unsflag = FALSE;
  165. newflag:
  166. switch (*(++fmt)) {
  168. case '+':
  169. fa.flags |= PLUSFLG;
  170. goto newflag;
  172. case '-':
  173. fa.minusflag++;
  174. goto newflag;
  176. case ' ':
  177. /*
  178.  * If the space and the + flag are present,
  179.  * the space flag will be ignored.
  180.  */
  181. fa.flags |= SPACEFLG;
  182. goto newflag;
  184. case '#':
  185. fa.flags |= HASHFLG;
  186. goto newflag;
  188. case '0':
  189. /*
  190.  * '0' is a flag.
  191.  */
  192. fa.fillc = '0';
  193. goto newflag;
  194. }
  195. if (*fmt == '*') {
  196. fmt++;
  197. fa.fldwidth = va_arg(args, int);
  198. /*
  199.  * A negative fieldwith is a minus flag with a
  200.  * positive fieldwidth.
  201.  */
  202. if (fa.fldwidth < 0) {
  203. fa.fldwidth = -fa.fldwidth;
  204. /* fa.minusflag ^= 1;*/
  205. fa.minusflag = 1;
  206. }
  207. } else while (c = *fmt, is_dig(c)) {
  208. fa.fldwidth *= 10;
  209. fa.fldwidth += c - '0';
  210. fmt++;
  211. }
  212. if (*fmt == '.') {
  213. fmt++;
  214. fa.signific = 0;
  215. if (*fmt == '*') {
  216. fmt++;
  217. fa.signific = va_arg(args, int);
  218. if (fa.signific < 0)
  219. fa.signific = 0;
  220. } else while (c = *fmt, is_dig(c)) {
  221. fa.signific *= 10;
  222. fa.signific += c - '0';
  223. fmt++;
  224. }
  225. }
  226. if (strchr("UCSIL", *fmt)) {
  227. /*
  228.  * Enhancements to K&R and ANSI:
  229.  *
  230.  * got a type specifyer
  231.  */
  232. if (*fmt == 'U') {
  233. fmt++;
  234. unsflag = TRUE;
  235. }
  236. if (!strchr("CSILZODX", *fmt)) {
  237. /*
  238.  * Got only 'U'nsigned specifyer,
  239.  * use default type and mode.
  240.  */
  241. type = 'I';
  242. mode = 'D';
  243. fmt--;
  244. } else if (!strchr("CSIL", *fmt)) {
  245. /*
  246.  * no type, use default
  247.  */
  248. type = 'I';
  249. mode = *fmt;
  250. } else {
  251. /*
  252.  * got CSIL
  253.  */
  254. type = *fmt++;
  255. if (!strchr("ZODX", mode = *fmt)) {
  256. fmt--;
  257. mode = 'D';/* default mode */
  258. }
  259. }
  260. } else switch(*fmt) {
  262. case 'h':
  263. type = 'S'; /* convert to type */
  264. goto getmode;
  266. case 'l':
  267. type = 'L'; /* convert to type */
  269. getmode:
  270. if (!strchr("udioxX", *(++fmt))) {
  271. fmt--;
  272. mode = 'D';
  273. } else {
  274. mode = *fmt;
  275. if (mode != 'x')
  276. mode = to_cap(mode);
  277. if (mode == 'U')
  278. unsflag = TRUE;
  279. else if (mode == 'I') /*XXX */
  280. mode = 'D';
  281. }
  282. break;
  283. case 'x':
  284. mode = 'x';
  285. goto havemode;
  286. case 'u':
  287. unsflag = TRUE;
  288. case 'o': case 'O':
  289. case 'd': case 'D':
  290. case 'i': case 'I':
  291. case 'p':
  292. case 'X':
  293. case 'z': case 'Z':
  294. mode = to_cap(*fmt);
  295. havemode:
  296. type = cap_ty(*fmt);
  297. if (mode == 'I') /*XXX kann entfallen*/
  298. mode = 'D'; /*wenn besseres uflg*/
  299. break;
  301. case '%':
  302. count += prc('%', &fa);
  303. continue;
  304. case ' ':
  305. count += prbuf("", &fa);
  306. continue;
  307. case 'c':
  308. c = va_arg(args, int);
  309. count += prc(c, &fa);
  310. continue;
  311. case 's':
  312. str = va_arg(args, char *);
  313. count += prstring(str, &fa);
  314. continue;
  315. case 'b':
  316. str = va_arg(args, char *);
  317. fa.signific = va_arg(args, int);
  318. count += prstring(str, &fa);
  319. continue;
  321. #ifndef NO_FLOATINGPOINT
  322. case 'e':
  323. if (fa.signific == -1)
  324. fa.signific = 6;
  325. dval = va_arg(args, double);
  326. ftoes(buf, dval, 0, fa.signific);
  327. count += prbuf(buf, &fa);
  328. continue;
  329. case 'f':
  330. if (fa.signific == -1)
  331. fa.signific = 6;
  332. dval = va_arg(args, double);
  333. ftofs(buf, dval, 0, fa.signific);
  334. count += prbuf(buf, &fa);
  335. continue;
  336. case 'g':
  337. if (fa.signific == -1)
  338. fa.signific = 6;
  339. if (fa.signific == 0)
  340. fa.signific = 1;
  341. dval = va_arg(args, double);
  342. gcvt(dval, fa.signific, buf);
  343. count += prbuf(buf, &fa);
  344. continue;
  345. #else
  346. # ifdef USE_FLOATINGARGS
  347. case 'e':
  348. case 'f':
  349. case 'g':
  350. dval = va_arg(args, double);
  351. continue;
  352. # endif
  353. #endif
  355. case 'r': /* recursive printf */
  356. case 'R': /* recursive printf */
  357. rfmt  = va_arg(args, char *);
  358. /*
  359.  * I don't know any portable way to get an arbitrary
  360.  * C object from a var arg list so I use a
  361.  * system-specific routine __va_arg_list() that knows
  362.  * if 'va_list' is an array. You will not be able to
  363.  * assign the value of __va_arg_list() but it works
  364.  * to be used as an argument of a function.
  365.  * It is a requirement for recursive printf to be able
  366.  * to use this function argument. If your system
  367.  * defines va_list to be an array you need to know this
  368.  * via autoconf or another mechanism.
  369.  * It would be nice to have something like
  370.  * __va_arg_list() in stdarg.h
  371.  */
  372. count += format(fun, farg, rfmt, __va_arg_list(args));
  373. continue;
  375. case 'n':
  376. {
  377. int *ip = va_arg(args, int *);
  379. *ip = count;
  380. }
  381. continue;
  383. default: /* Unknown '%' format */
  384. sfmt++; /* Dont't print '%'   */
  385. count += fmt - sfmt;
  386. while (sfmt < fmt)
  387. (*fun)(*(sfmt++), farg);
  388. if (*fmt == '') {
  389. fmt--;
  390. continue;
  391. } else {
  392. (*fun)(*fmt, farg);
  393. count++;
  394. continue;
  395. }
  396. }
  397. /*
  398.  * print numbers:
  399.  * first prepare type 'C'har, 'S'hort, 'I'nt, or 'L'ong
  400.  */
  401. switch(type) {
  403. case 'C':
  404. c = va_arg(args, int);
  405. val = c; /* extend sign here */
  406. if (unsflag || mode != 'D')
  407. #ifdef DO_MASK
  408. val &= CHARMASK;
  409. #else
  410. val = (unsigned char)val;
  411. #endif
  412. break;
  413. case 'S':
  414. sh = va_arg(args, int);
  415. val = sh; /* extend sign here */
  416. if (unsflag || mode != 'D')
  417. #ifdef DO_MASK
  418. val &= SHORTMASK;
  419. #else
  420. val = (unsigned short)val;
  421. #endif
  422. break;
  423. case 'I':
  424. default:
  425. i = va_arg(args, int);
  426. val = i; /* extend sign here */
  427. if (unsflag || mode != 'D')
  428. #ifdef DO_MASK
  429. val &= INTMASK;
  430. #else
  431. val = (unsigned int)val;
  432. #endif
  433. break;
  434. case 'P':
  435. case 'L':
  436. val = va_arg(args, long);
  437. break;
  438. }
  440. /*
  441.  * Final print out, take care of mode:
  442.  * mode is one of: 'O'ctal, 'D'ecimal, or he'X'
  443.  * oder 'Z'weierdarstellung.
  444.  */
  445. fa.bufp = &buf[sizeof(buf)-1];
  446. *--fa.bufp = '';
  448. if (val == 0 && mode != 'D') {
  449. printzero:
  450. /*
  451.  * Printing '0' with fieldwidth 0 results in no chars.
  452.  */
  453. fa.lzero = -1;
  454. if (fa.signific >= 0)
  455. fa.fillc = ' ';
  456. count += prstring("0", &fa);
  457. continue;
  458. } else switch(mode) {
  460. case 'D':
  461. if (!unsflag && val < 0) {
  462. fa.prefix = "-";
  463. fa.prefixlen = 1;
  464. val = -val;
  465. } else if (fa.flags & PLUSFLG) {
  466. fa.prefix = "+";
  467. fa.prefixlen = 1;
  468. } else if (fa.flags & SPACEFLG) {
  469. fa.prefix = " ";
  470. fa.prefixlen = 1;
  471. }
  472. if (val == 0)
  473. goto printzero;
  474. case 'U':
  475. /* output a long unsigned decimal number */
  476. prdnum(val, &fa);
  477. break;
  478. case 'O':
  479. /* output a long octal number */
  480. if (fa.flags & HASHFLG) {
  481. fa.prefix = "0";
  482. fa.prefixlen = 1;
  483. }
  484. pronum(val & 07, &fa);
  485. if ((res = (val>>3) & rshiftmask(long, 3)) != 0)
  486. pronum(res, &fa);
  487. break;
  488. case 'p':
  489. case 'x':
  490. /* output a hex long */
  491. if (fa.flags & HASHFLG) {
  492. fa.prefix = "0x";
  493. fa.prefixlen = 2;
  494. }
  495. prxnum(val & 0xF, &fa);
  496. if ((res = (val>>4) & rshiftmask(long, 4)) != 0)
  497. prxnum(res, &fa);
  498. break;
  499. case 'P':
  500. case 'X':
  501. /* output a hex long */
  502. if (fa.flags & HASHFLG) {
  503. fa.prefix = "0X";
  504. fa.prefixlen = 2;
  505. }
  506. prXnum(val & 0xF, &fa);
  507. if ((res = (val>>4) & rshiftmask(long, 4)) != 0)
  508. prXnum(res, &fa);
  509. break;
  510. case 'Z':
  511. /* output a binary long */
  512. prnum(val & 0x1, 2, &fa);
  513. if ((res = (val>>1) & rshiftmask(long, 1)) != 0)
  514. prnum(res, 2, &fa);
  515. }
  516. fa.lzero = -1;
  517. /*
  518.  * If a precision (fielwidth) is specified
  519.  * on diouXx conversions, the '0' flag is ignored.
  520.  */
  521. if (fa.signific >= 0)
  522. fa.fillc = ' ';
  523. count += prbuf(fa.bufp, &fa);
  524. }
  525. return (count);
  526. }
  528. /*
  529.  * Routines to print (not negative) numbers in an arbitrary base
  530.  */
  531. LOCAL unsigned char dtab[]  = "0123456789abcdef";
  532. LOCAL unsigned char udtab[] = "0123456789ABCDEF";
  534. LOCAL void prnum(val, base, fa)
  535. register Ulong val;
  536. register unsigned base;
  537. f_args *fa;
  538. {
  539. register char *p = fa->bufp;
  541. do {
  542. *--p = dtab[modlbys(val, base)];
  543. val = divlbys(val, base);
  544. } while (val > 0);
  546. fa->bufp = p;
  547. }
  549. LOCAL void prdnum(val, fa)
  550. register Ulong val;
  551. f_args *fa;
  552. {
  553. register char *p = fa->bufp;
  555. do {
  556. *--p = dtab[modlbys(val, (unsigned)10)];
  557. val = divlbys(val, (unsigned)10);
  558. } while (val > 0);
  560. fa->bufp = p;
  561. }
  563. /*
  564.  * We may need to use division here too (PDP-11, non two's complement ...)
  565.  */
  566. LOCAL void pronum(val, fa)
  567. register Ulong val;
  568. f_args *fa;
  569. {
  570. register char *p = fa->bufp;
  572. do {
  573. *--p = dtab[val & 7];
  574. val >>= 3;
  575. } while (val > 0);
  577. fa->bufp = p;
  578. }
  580. LOCAL void prxnum(val, fa)
  581. register Ulong val;
  582. f_args *fa;
  583. {
  584. register char *p = fa->bufp;
  586. do {
  587. *--p = dtab[val & 15];
  588. val >>= 4;
  589. } while (val > 0);
  591. fa->bufp = p;
  592. }
  594. LOCAL void prXnum(val, fa)
  595. register Ulong val;
  596. f_args *fa;
  597. {
  598. register char *p = fa->bufp;
  600. do {
  601. *--p = udtab[val & 15];
  602. val >>= 4;
  603. } while (val > 0);
  605. fa->bufp = p;
  606. }
  608. /*
  609.  * Final buffer print out routine.
  610.  */
  611. LOCAL int prbuf(s, fa)
  612. register const char *s;
  613. f_args *fa;
  614. {
  615. register int diff;
  616. register int rfillc;
  617. register long arg = fa->farg;
  618. register void (*fun) __PR((char, long)) = fa->outf;
  619. register int count;
  620. register int lzero = 0;
  622. count = strlen(s);
  624. if (fa->lzero < 0 && count < fa->signific)
  625. lzero = fa->signific - count;
  626. diff = fa->fldwidth - lzero - count - fa->prefixlen;
  627. count += lzero;
  628. if (diff > 0)
  629. count += diff;
  631. if (fa->prefixlen && fa->fillc != ' ') {
  632. while (*fa->prefix != '')
  633. (*fun)(*fa->prefix++, arg);
  634. }
  635. if (!fa->minusflag) {
  636. rfillc = fa->fillc;
  637. while (--diff >= 0)
  638. (*fun)(rfillc, arg);
  639. }
  640. if (fa->prefixlen && fa->fillc == ' ') {
  641. while (*fa->prefix != '')
  642. (*fun)(*fa->prefix++, arg);
  643. }
  644. if (lzero > 0) {
  645. rfillc = '0';
  646. while (--lzero >= 0)
  647. (*fun)(rfillc, arg);
  648. }
  649. while (*s != '')
  650. (*fun)(*s++, arg);
  651. if (fa->minusflag) {
  652. rfillc = ' ';
  653. while (--diff >= 0)
  654. (*fun)(rfillc, arg);
  655. }
  656. return (count);
  657. }
  659. /*
  660.  * Print out one char, allowing prc('')
  661.  * Similar to prbuf()
  662.  */
  663. #ifdef PROTOTYPES
  665. LOCAL int prc(char c, f_args *fa)
  667. #else
  668. LOCAL int prc(c, fa)
  669. char c;
  670. f_args *fa;
  671. #endif
  672. {
  673. register int diff;
  674. register int rfillc;
  675. register long arg = fa->farg;
  676. register void (*fun) __PR((char, long)) = fa->outf;
  677. register int count;
  679. count = 1;
  680. diff = fa->fldwidth - 1;
  681. if (diff > 0)
  682. count += diff;
  684. if (!fa->minusflag) {
  685. rfillc = fa->fillc;
  686. while (--diff >= 0)
  687. (*fun)(rfillc, arg);
  688. }
  689. (*fun)(c, arg);
  690. if (fa->minusflag) {
  691. rfillc = ' ';
  692. while (--diff >= 0)
  693. (*fun)(rfillc, arg);
  694. }
  695. return (count);
  696. }
  698. /*
  699.  * String output routine.
  700.  * If fa->signific is >= 0, it uses only fa->signific chars.
  701.  * If fa->signific is 0, print no characters.
  702.  */
  703. LOCAL int prstring(s, fa)
  704. register const char *s;
  705. f_args *fa;
  706. {
  707. register char *bp;
  708. register int signific;
  710. if (s == NULL)
  711. return (prbuf("(NULL POINTER)", fa));
  713. if (fa->signific < 0)
  714. return (prbuf(s, fa));
  716. bp = fa->buf;
  717. signific = fa->signific;
  719. while (--signific >= 0 && *s != '')
  720. *bp++ = *s++;
  721. *bp = '';
  723. return (prbuf(fa->buf, fa));
  724. }